Rewrite llvm.flt.rounds to "1" for now, and disallow llvm.flt.rounds.

Until there is an intrinsic to *set* the rounding mode,
this intrinsic to *get* the rounding mode isn't so useful.
Separately we will add a test that for each platform, the
initial rounding mode is "1" (round to nearest).  That is
the case right now for x86, ARM, and MIPS.
(see https://codereview.chromium.org/16785003/)

BUG=https://code.google.com/p/nativeclient/issues/detail?id=3491
R=mseaborn@chromium.org

Review URL: https://codereview.chromium.org/17229007

3 files changed, 77 insertions, 3 deletions

diff --git a/lib/Analysis/NaCl/PNaClABIVerifyModule.cpp b/lib/Analysis/NaCl/PNaClABIVerifyModule.cpp
index 3a422288d8..288d5da2ad 100644
--- a/lib/Analysis/NaCl/PNaClABIVerifyModule.cpp
+++ b/lib/Analysis/NaCl/PNaClABIVerifyModule.cpp
@@ -249,6 +249,10 @@ bool PNaClABIVerifyModule::isWhitelistedIntrinsic(const Function *F,
     // We run -lower-expect to convert Intrinsic::expect into branch weights
     // and consume in the middle-end. The backend just ignores llvm.expect.
     case Intrinsic::expect:
+    // For FLT_ROUNDS macro from float.h. It works for ARM and X86
+    // (but not MIPS). Also, wait until we add a set_flt_rounds intrinsic
+    // before we bless this.
+    case Intrinsic::flt_rounds:
       return false;
 
     // (3) Dev intrinsics.
@@ -258,9 +262,6 @@ bool PNaClABIVerifyModule::isWhitelistedIntrinsic(const Function *F,
     case Intrinsic::ctlz: // Support via compiler_rt if arch doesn't have it?
     case Intrinsic::ctpop: // Support via compiler_rt if arch doesn't have it?
     case Intrinsic::cttz: // Support via compiler_rt if arch doesn't have it?
-    case Intrinsic::flt_rounds: // For FLT_ROUNDS macro from float.h.
-      // We do not have fesetround() in newlib, can we return a
-      // consistent rounding mode though?
     case Intrinsic::nacl_target_arch: // Used by translator self-build.
     case Intrinsic::pow: // Rounding is supposed to be the same as libm.
     case Intrinsic::powi: // Rounding not defined: support with fast-math?
diff --git a/lib/Transforms/NaCl/PNaClABISimplify.cpp b/lib/Transforms/NaCl/PNaClABISimplify.cpp
index 0fd7176ed9..a85829eb3b 100644
--- a/lib/Transforms/NaCl/PNaClABISimplify.cpp
+++ b/lib/Transforms/NaCl/PNaClABISimplify.cpp
@@ -25,6 +25,8 @@ void llvm::PNaClABISimplifyAddPreOptPasses(PassManager &PM) {
   // LowerExpect converts Intrinsic::expect into branch weights,
   // which can then be removed after BlockPlacement.
   PM.add(createLowerExpectIntrinsicPass());
+  // Rewrite unsupported intrinsics to simpler constructs.
+  PM.add(createRewriteLLVMIntrinsicsPass());
   // LowerInvoke prevents use of C++ exception handling, which is not
   // yet supported in the PNaCl ABI.
   PM.add(createLowerInvokePass());
diff --git a/lib/Transforms/NaCl/RewriteLLVMIntrinsics.cpp b/lib/Transforms/NaCl/RewriteLLVMIntrinsics.cpp
new file mode 100644
index 0000000000..17cd2347cc
--- /dev/null
+++ b/lib/Transforms/NaCl/RewriteLLVMIntrinsics.cpp
@@ -0,0 +1,71 @@
+//===- RewriteLLVMIntrinsics.cpp - Rewrite LLVM intrinsics to other values ===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+//
+// This pass replaces calls to LLVM intrinsics that are *not* part of the
+// PNaCl stable bitcode ABI into simpler values.
+//
+//===----------------------------------------------------------------------===//
+
+#include "llvm/IR/Instructions.h"
+#include "llvm/IR/Intrinsics.h"
+#include "llvm/IR/Module.h"
+#include "llvm/Pass.h"
+#include "llvm/Transforms/NaCl.h"
+
+using namespace llvm;
+
+namespace {
+  class RewriteLLVMIntrinsics : public ModulePass {
+  public:
+    static char ID;
+    RewriteLLVMIntrinsics() : ModulePass(ID) {
+      // This is a module pass because this makes it easier to access uses
+      // of global intrinsic functions.
+      initializeRewriteLLVMIntrinsicsPass(*PassRegistry::getPassRegistry());
+    }
+
+    virtual bool runOnModule(Module &M);
+  };
+}
+
+char RewriteLLVMIntrinsics::ID = 0;
+INITIALIZE_PASS(RewriteLLVMIntrinsics, "rewrite-llvm-intrinsic-calls",
+                "Rewrite LLVM intrinsic calls to simpler expressions",
+                false, false)
+
+bool RewriteLLVMIntrinsics::runOnModule(Module &M) {
+  bool Changed = false;
+
+  // Iterate over all uses of the llvm.flt.rounds, and replace it with
+  // the constant "1" (round-to-nearest).  Until we add a second intrinsic
+  // like llvm.set.flt.round it is impossible to have a rounding mode
+  // that is not the initial rounding mode (round-to-nearest).
+  // We can remove this rewrite after adding a set() intrinsic.
+  Function *FltRounds = Intrinsic::getDeclaration(&M, Intrinsic::flt_rounds);
+  Type *RetType = FltRounds->getFunctionType()->getReturnType();
+  for (Value::use_iterator UI = FltRounds->use_begin(),
+           UE = FltRounds->use_end(); UI != UE;) {
+    Value *Use = *UI++;
+    if (CallInst *Call = dyn_cast<CallInst>(Use)) {
+      Constant *C = ConstantInt::get(RetType, 1);
+      Call->replaceAllUsesWith(C);
+      Call->eraseFromParent();
+      Changed = true;
+    } else {
+      report_fatal_error("Taking the address of llvm.flt.rounds is invalid");
+    }
+  }
+  FltRounds->eraseFromParent();
+
+  return Changed;
+}
+
+ModulePass *llvm::createRewriteLLVMIntrinsicsPass() {
+  return new RewriteLLVMIntrinsics();
+}