Restore ability for C++ API users to Enable IPRA.

Summary:
Prior to r310876 one of our out-of-tree targets was enabling IPRA by modifying
the TargetOptions::EnableIPRA. This no longer works on current trunk since the
useIPRA() hook overrides any values that are set in advance. This patch adjusts
the behaviour of the hook so that API users and useIPRA() can both enable it
but useIPRA() cannot disable it if the API user already enabled it.

Reviewers: arsenm

Reviewed By: arsenm

Subscribers: wdng, mgorny, llvm-commits

Differential Revision: https://reviews.llvm.org/D38043

llvm-svn: 354692

Author: dsandersllvm

llvm/lib/CodeGen/TargetPassConfig.cpp

@@ -407,7 +407,7 @@ TargetPassConfig::TargetPassConfig(LLVMTargetMachine &TM, PassManagerBase &pm)
     TM.Options.EnableIPRA = EnableIPRA;
   else {
     // If not explicitly specified, use target default.
-    TM.Options.EnableIPRA = TM.useIPRA();
+    TM.Options.EnableIPRA |= TM.useIPRA();
   }
 
   if (TM.Options.EnableIPRA)

llvm/unittests/CodeGen/CMakeLists.txt

@@ -20,6 +20,7 @@ add_llvm_unittest(CodeGenTests
   MachineOperandTest.cpp
   ScalableVectorMVTsTest.cpp
   TypeTraitsTest.cpp
+  TargetOptionsTest.cpp
   )
 
 add_subdirectory(GlobalISel)

llvm/unittests/CodeGen/TargetOptionsTest.cpp

@@ -0,0 +1,74 @@
+#include "llvm/Target/TargetOptions.h"
+#include "llvm/IR/LLVMContext.h"
+#include "llvm/IR/LegacyPassManager.h"
+#include "llvm/Support/TargetRegistry.h"
+#include "llvm/Support/TargetSelect.h"
+#include "llvm/Target/TargetMachine.h"
+#include "gtest/gtest.h"
+
+using namespace llvm;
+
+namespace llvm {
+  void initializeTestPassPass(PassRegistry &);
+}
+
+namespace {
+
+void initLLVM() {
+  InitializeAllTargets();
+  InitializeAllTargetMCs();
+  InitializeAllAsmPrinters();
+  InitializeAllAsmParsers();
+
+  PassRegistry *Registry = PassRegistry::getPassRegistry();
+  initializeCore(*Registry);
+  initializeCodeGen(*Registry);
+}
+
+/// Create a TargetMachine. We need a target that doesn't have IPRA enabled by
+/// default. That turns out to be all targets at the moment, so just use X86.
+std::unique_ptr<TargetMachine> createTargetMachine(bool EnableIPRA) {
+  Triple TargetTriple("x86_64--");
+  std::string Error;
+  const Target *T = TargetRegistry::lookupTarget("", TargetTriple, Error);
+  if (!T)
+    return nullptr;
+
+  TargetOptions Options;
+  Options.EnableIPRA = EnableIPRA;
+  return std::unique_ptr<TargetMachine>(T->createTargetMachine(
+      "X86", "", "", Options, None, None, CodeGenOpt::Aggressive));
+}
+
+typedef std::function<void(bool)> TargetOptionsTest;
+
+static void targetOptionsTest(bool EnableIPRA) {
+  LLVMContext Context;
+  std::unique_ptr<TargetMachine> TM = createTargetMachine(EnableIPRA);
+  // This test is designed for the X86 backend; stop if it is not available.
+  if (!TM)
+    return;
+  legacy::PassManager PM;
+  LLVMTargetMachine &LLVMTM = static_cast<LLVMTargetMachine &>(*TM);
+
+  TargetPassConfig &TPC = *LLVMTM.createPassConfig(PM);
+  (void)TPC;
+
+  ASSERT_TRUE(TM->Options.EnableIPRA == EnableIPRA);
+}
+
+} // End of anonymous namespace.
+
+TEST(TargetOptionsTest, IPRASetToOff) {
+  targetOptionsTest(false);
+}
+
+TEST(TargetOptionsTest, IPRASetToOn) {
+  targetOptionsTest(true);
+}
+
+int main(int argc, char **argv) {
+  ::testing::InitGoogleTest(&argc, argv);
+  initLLVM();
+  return RUN_ALL_TESTS();
+}