Remove Emscripten support

lib/Transforms/NaCl/ExpandVarArgs.cpp

 //===- ExpandVarArgs.cpp - Expand out variable argument function calls-----===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 //
 // This pass expands out all use of variable argument functions.
@@ skipping 28 matching lines @@
   }
   virtual bool runOnModule(Module &M);
 };
 }
 
 char ExpandVarArgs::ID = 0;
 INITIALIZE_PASS(ExpandVarArgs, "expand-varargs",
                 "Expand out variable argument function definitions and calls",
                 false, false)
 
-static bool isEmscriptenJSArgsFunc(Module *M, StringRef Name) {
-  // TODO(jfb) Make these intrinsics in clang and remove the assert: these
-  //           intrinsics should only exist for Emscripten.
-  bool isEmscriptenSpecial = Name.equals("emscripten_asm_const_int") ||
-                             Name.equals("emscripten_asm_const_double") ||
-                             Name.equals("emscripten_landingpad") ||
-                             Name.equals("emscripten_resume");
-  assert(isEmscriptenSpecial ? Triple(M->getTargetTriple()).isOSEmscripten()
-                             : true);
-  return isEmscriptenSpecial;
-}
-
 static bool ExpandVarArgFunc(Module *M, Function *Func) {
-  if (isEmscriptenJSArgsFunc(M, Func->getName()))
-    return false;
-
   Type *PtrType = Type::getInt8PtrTy(Func->getContext());
 
   FunctionType *FTy = Func->getFunctionType();
   SmallVector<Type *, 8> Params(FTy->param_begin(), FTy->param_end());
   Params.push_back(PtrType);
   FunctionType *NFTy =
       FunctionType::get(FTy->getReturnType(), Params, /*isVarArg=*/false);
   Function *NewFunc = RecreateFunction(Func, NFTy);
 
   // Declare the new argument as "noalias".
@@ skipping 87 matching lines @@
 }
 
 // ExpandVarArgCall() converts a CallInst or InvokeInst to expand out
 // of varargs.  It returns whether the module was modified.
 template <class InstType>
 static bool ExpandVarArgCall(Module *M, InstType *Call, DataLayout *DL) {
   FunctionType *FuncType = cast<FunctionType>(
       Call->getCalledValue()->getType()->getPointerElementType());
   if (!FuncType->isFunctionVarArg())
     return false;
-  if (auto *F = dyn_cast<Function>(Call->getCalledValue()))
-    if (isEmscriptenJSArgsFunc(M, F->getName()))
-      return false;
 
   Function *F = Call->getParent()->getParent();
   LLVMContext &Ctx = M->getContext();
 
   SmallVector<AttributeSet, 8> Attrs;
   Attrs.push_back(Call->getAttributes().getFnAttributes());
   Attrs.push_back(Call->getAttributes().getRetAttributes());
 
   // Split argument list into fixed and variable arguments.
   SmallVector<Value *, 8> FixedArgs;
@@ skipping 127 matching lines @@
     }
 
     if (F->isVarArg())
       Changed |= ExpandVarArgFunc(&M, F);
   }
 
   return Changed;
 }
 
 ModulePass *llvm::createExpandVarArgsPass() { return new ExpandVarArgs(); }