Disable inapplicable PNaCl SIMD lowering passes.

Author: sunfishcode

lib/Transforms/NaCl/PNaClABISimplify.cpp

@@ -129,22 +129,28 @@ void llvm::PNaClABISimplifyAddPostOptPasses(PassManagerBase &PM) {
 
   // Vector simplifications.
   //
+#if 0 // EMSCRIPTEN: We can handle vector shuffles.
   // The following pass relies on ConstantInsertExtractElementIndex running
   // after it, and it must run before GlobalizeConstantVectors because the mask
   // argument of shufflevector must be a constant (the pass would otherwise
   // violate this requirement).
   PM.add(createExpandShuffleVectorPass());
+#endif
   // We should not place arbitrary passes after ExpandConstantExpr
   // because they might reintroduce ConstantExprs.
   PM.add(createExpandConstantExprPass());
+#if 0 // EMSCRIPTEN: We can handle constant vectors.
   // GlobalizeConstantVectors does not handle nested ConstantExprs, so we
   // run ExpandConstantExpr first.
   PM.add(createGlobalizeConstantVectorsPass());
+#endif
   // The following pass inserts GEPs, it must precede ExpandGetElementPtr. It
   // also creates vector loads and stores, the subsequent pass cleans them up to
   // fix their alignment.
   PM.add(createConstantInsertExtractElementIndexPass());
+#if 0 // EMSCRIPTEN: We can handle unaligned vector loads and stores.
   PM.add(createFixVectorLoadStoreAlignmentPass());
+#endif
 
   // Optimization passes and ExpandByVal introduce
   // memset/memcpy/memmove intrinsics with a 64-bit size argument.

lib/Transforms/NaCl/PromoteIntegers.cpp

@@ -112,24 +112,24 @@ static bool shouldConvert(Value *Val) {
 // Return a constant which has been promoted to a legal size.
 static Value *convertConstant(Constant *C, bool SignExt=false) {
   assert(shouldConvert(C));
+#if 0 // EMSCRIPTEN: Generalize this code to work on any width and any constant
   if (isa<UndefValue>(C)) {
     return UndefValue::get(getPromotedType(C->getType()));
   } else if (ConstantInt *CInt = dyn_cast<ConstantInt>(C)) {
-#if 0 // XXX EMSCRIPTEN: Generalize this code to work on any bit width.
     return ConstantInt::get(
         getPromotedType(C->getType()),
         SignExt ? CInt->getSExtValue() : CInt->getZExtValue(),
         /*isSigned=*/SignExt);
-#else
-    unsigned BitWidth = getPromotedType(C->getType())->getIntegerBitWidth();
-    const APInt &Value = CInt->getValue();
-    return ConstantInt::get(C->getContext(),
-                            SignExt ? Value.sext(BitWidth) : Value.zext(BitWidth));
-#endif
   } else {
     errs() << "Value: " << *C << "\n";
     report_fatal_error("Unexpected constant value");
   }
+#else
+  Type *ProTy = getPromotedType(C->getType());
+  return SignExt ?
+         ConstantExpr::getSExt(C, ProTy) :
+         ConstantExpr::getZExt(C, ProTy);
+#endif
 }
 
 namespace {