[BOLT] Fix bug in shortening peephole.

Summary: The arithmetic shortening code on x86 was broken. It would sometimes shorten instructions with immediate operands that wouldn't fit into 8 bits. (cherry picked from FBD6444699)
llvm · Nov 30, 2017 · a71b570 · a71b570
1 parent 0bab742
commit a71b570
Show file tree

Hide file tree

Showing 2 changed files with 29 additions and 6 deletions.
diff --git a/bolt/Passes/BinaryPasses.cpp b/bolt/Passes/BinaryPasses.cpp
@@ -974,13 +974,33 @@ void SimplifyConditionalTailCalls::runOnFunctions(
          << ".\n";
 }
 
-void Peepholes::shortenInstructions(BinaryContext &BC,
-                                    BinaryFunction &Function) {
+uint64_t Peepholes::shortenInstructions(BinaryContext &BC,
+                                        BinaryFunction &Function) {
+  std::string DebugStr;
+  (void)DebugStr;
+  uint64_t Count = 0;
   for (auto &BB : Function) {
     for (auto &Inst : BB) {
-      BC.MIA->shortenInstruction(Inst);
+      DEBUG(
+        if (opts::Verbosity > 1) {
+          DebugStr.clear();
+          raw_string_ostream OS(DebugStr);
+          BC.printInstruction(OS, Inst, 0, &Function);
+          OS.str();
+        });
+      if (BC.MIA->shortenInstruction(Inst)) {
+        DEBUG(
+          if (opts::Verbosity > 1) {
+            dbgs() << "BOLT-INFO: peephole, shortening:\n"
+                   << "BOLT-INFO:    " << DebugStr
+                   << "BOLT-INFO: to:";
+            BC.printInstruction(dbgs(), Inst, 0, &Function);
+          });
+        ++Count;
+      }
     }
   }
+  return Count;
 }
 
 void Peepholes::addTailcallTraps(BinaryContext &BC,
@@ -1041,7 +1061,7 @@ void Peepholes::runOnFunctions(BinaryContext &BC,
     auto &Function = It.second;
     if (shouldOptimize(Function)) {
       if (Opts & opts::PEEP_SHORTEN)
-        shortenInstructions(BC, Function);
+        NumShortened += shortenInstructions(BC, Function);
       if (Opts & opts::PEEP_DOUBLE_JUMPS)
         NumDoubleJumps += fixDoubleJumps(BC, Function, false);
       if (Opts & opts::PEEP_TAILCALL_TRAPS)
@@ -1050,7 +1070,9 @@ void Peepholes::runOnFunctions(BinaryContext &BC,
         removeUselessCondBranches(BC, Function);
     }
   }
-  outs() << "BOLT-INFO: Peephole: " << NumDoubleJumps
+  outs() << "BOLT-INFO: Peephole: " << NumShortened
+         << " instructions shortened.\n"
+         << "BOLT-INFO: Peephole: " << NumDoubleJumps
          << " double jumps patched.\n"
          << "BOLT-INFO: Peephole: " << TailCallTraps
          << " tail call traps inserted.\n"

diff --git a/bolt/Passes/BinaryPasses.h b/bolt/Passes/BinaryPasses.h
@@ -301,13 +301,14 @@ class SimplifyConditionalTailCalls : public BinaryFunctionPass {
 
 /// Perform simple peephole optimizations.
 class Peepholes : public BinaryFunctionPass {
+  uint64_t NumShortened{0};
   uint64_t NumDoubleJumps{0};
   uint64_t TailCallTraps{0};
   uint64_t NumUselessCondBranches{0};
 
   /// Attempt to use the minimum operand width for arithmetic, branch and
   /// move instructions.
-  void shortenInstructions(BinaryContext &BC, BinaryFunction &Function);
+  uint64_t shortenInstructions(BinaryContext &BC, BinaryFunction &Function);
 
   /// Add trap instructions immediately after indirect tail calls to prevent
   /// the processor from decoding instructions immediate following the