Added another optimization pass to make vectorizing possible

[emmettneyman]

Summary

I noticed that my code wasn't going deep into the loop vectorizer code so added another pass that makes it go further.

[emmettneyman]

• minor style fix

[morehouse]

clang/tools/clang-fuzzer/handle-llvm/handle_llvm.cpp

90

If you have to pass that many parameters to a 3 line function, just inline instead.

126

Is TM guaranteed to be an LLVMTargetMachine?

[emmettneyman]

clang/tools/clang-fuzzer/handle-llvm/handle_llvm.cpp

126

Yes, since the target triple will always be X86.

[emmettneyman]

• Inlined function

[morehouse]

clang/tools/clang-fuzzer/handle-llvm/handle_llvm.cpp

115

I think you can avoid creating a Triple and instead just call M->getTargetTriple() in lookupTarget below.

[emmettneyman]

clang/tools/clang-fuzzer/handle-llvm/handle_llvm.cpp

115

M->getTargetTriple() returns a std::string and both lookupTarget() and TargetLibraryInfoWrapperPass() take a Triple object.

[emmettneyman]

Rebase

clang/tools/clang-fuzzer/handle-llvm/handle_llvm.cpp

static void getOptLevel(const std::vector<const char *> &ExtraArgs,
   }
 }
 
 static void ErrorAndExit(std::string message) {
   errs()<< "ERROR: " << message << "\n";
   std::exit(1);
 }
 
+// Helper function that returns a *TargetMachine, used by OptLLVM
+static TargetMachine* GetTargetMachine(Triple TheTriple, StringRef CPUStr,
+                                       StringRef FeaturesStr,
+                                       const TargetOptions &Options,
+                                       CodeGenOpt::Level OLvl) {
+  std::string E;
+  const Target *TheTarget = TargetRegistry::lookupTarget(MArch, TheTriple, E);
+  return TheTarget->createTargetMachine(TheTriple.getTriple(), CPUStr,
+                                        FeaturesStr, Options, getRelocModel(),
+                                        getCodeModel(), OLvl);
+}
+
 // Helper function to add optimization passes to the TargetMachine at the 
 // specified optimization level, OptLevel
 static void AddOptimizationPasses(legacy::PassManagerBase &MPM,
                                   CodeGenOpt::Level OptLevel,
                                   unsigned SizeLevel) {
   // Create and initialize a PassManagerBuilder
   PassManagerBuilder Builder;
   Builder.OptLevel = OptLevel;
   Builder.SizeLevel = SizeLevel;
   Builder.Inliner = createFunctionInliningPass(OptLevel, SizeLevel, false);
   Builder.LoopVectorize = true;
   Builder.populateModulePassManager(MPM);
 }
 
 // Mimics the opt tool to run an optimization pass over the provided IR
 static std::string OptLLVM(const std::string &IR, CodeGenOpt::Level OLvl) {
   // Create a module that will run the optimization passes
   SMDiagnostic Err;
   LLVMContext Context;
   std::unique_ptr<Module> M = parseIR(MemoryBufferRef(IR, "IR"), Err, Context);
   if (!M || verifyModule(*M, &errs()))
     ErrorAndExit("Could not parse IR");
 
+  Triple ModuleTriple(M->getTargetTriple());
+  const TargetOptions Options = InitTargetOptionsFromCodeGenFlags();
+  std::unique_ptr<TargetMachine> TM(GetTargetMachine(ModuleTriple, getCPUStr(),
+                                    getFeaturesStr(), Options, OLvl));
   setFunctionAttributes(getCPUStr(), getFeaturesStr(), *M);
-  
   legacy::PassManager Passes;
-  Triple ModuleTriple(M->getTargetTriple());
   
   Passes.add(new TargetLibraryInfoWrapperPass(ModuleTriple));
-  Passes.add(createTargetTransformInfoWrapperPass(TargetIRAnalysis()));
+  Passes.add(createTargetTransformInfoWrapperPass(TM->getTargetIRAnalysis()));
+
+  auto &LTM = static_cast<LLVMTargetMachine &>(*TM);
+  Passes.add(LTM.createPassConfig(Passes));
+
   Passes.add(createVerifierPass());
 
   AddOptimizationPasses(Passes, OLvl, 0);
-  
   // Add a pass that writes the optimized IR to an output stream
   std::string outString;
   raw_string_ostream OS(outString);
   Passes.add(createPrintModulePass(OS, "", false));
 
   Passes.run(*M);
 
   return OS.str();