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.

119

Is TM guaranteed to be an LLVMTargetMachine?

[emmettneyman]

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

119

Yes, since the target triple will always be X86.

[emmettneyman]

• Inlined function

[morehouse]

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

103

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

103

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 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::string E;
+  const Target *TheTarget = TargetRegistry::lookupTarget(MArch, ModuleTriple, E);
+  TargetMachine *Machine =
+      TheTarget->createTargetMachine(M->getTargetTriple(), getCPUStr(),
+                                     getFeaturesStr(), Options, getRelocModel(),
+                                     getCodeModel(), OLvl);
+  std::unique_ptr<TargetMachine> TM(Machine);
   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()));
+
+  LLVMTargetMachine &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();