[BOLT] Use MCInstPrinter in createRetpolineFunctionTag

[Amir]

Summary

Make retpoline functions invariant of X86 register numbers.
retpoline-synthetic.test is known to fail NFC testing due to shifting
register numbers. Use canonical register names instead of tablegen
numbers.

Before:

__retpoline_r51_
__retpoline_mem_r58+DATAat0x200fe8
__retpoline_mem_r51+0
__retpoline_mem_r132+0+8*53

After:

__retpoline_%rax_
__retpoline_mem_%rip+DATAat0x200fe8
__retpoline_mem_%rax+0
__retpoline_mem_%r12+0+8*%rbx

Test Plan:

• Revert 67bd3c58c0c7389e39c5a2f4d3b1a30459ccf5b7 that touches X86RegisterInfo.td.
• retpoline-synthetic.test passes in NFC mode with this diff, fails without it.

[Amir]

Update retpoline-synthetic.test

[Amir]

Add llvm-strings test dependency

[rafauler]

Thanks

[Amir]

Fix test

bolt/lib/Passes/RetpolineInsertion.cpp

 // The user can determine when to assume %r11 available using r11-availability
 // option, by default %r11 is assumed not available.
 // Adding lfence instruction to the body of the speculate code is enabled by
 // default and can be controlled by the user using retpoline-lfence option.
 //
 //===----------------------------------------------------------------------===//
 
 #include "bolt/Passes/RetpolineInsertion.h"
+#include "llvm/MC/MCInstPrinter.h"
 #include "llvm/Support/raw_ostream.h"
 
 #define DEBUG_TYPE "bolt-retpoline"
 
 using namespace llvm;
 using namespace bolt;
 namespace opts {
 
BinaryFunction *createNewRetpoline(BinaryContext &BC,
 
   NewRetpoline->updateState(BinaryFunction::State::CFG_Finalized);
   return NewRetpoline;
 }
 
 std::string createRetpolineFunctionTag(BinaryContext &BC,
                                        const IndirectBranchInfo &BrInfo,
                                        bool R11Available) {
-  if (BrInfo.isReg())
-    return "__retpoline_r" + to_string(BrInfo.BranchReg) + "_";
+  std::string Tag;
+  llvm::raw_string_ostream TagOS(Tag);
+  TagOS << "__retpoline_";
+
+  if (BrInfo.isReg()) {
+    BC.InstPrinter->printRegName(TagOS, BrInfo.BranchReg);
+    TagOS << "_";
+    TagOS.flush();
+    return Tag;
+  }
 
   // Memory Branch
   if (R11Available)
     return "__retpoline_r11";
 
-  std::string Tag = "__retpoline_mem_";
-
   const IndirectBranchInfo::MemOpInfo &MemRef = BrInfo.Memory;
 
-  std::string DispExprStr;
-  if (MemRef.DispExpr) {
-    llvm::raw_string_ostream Ostream(DispExprStr);
-    MemRef.DispExpr->print(Ostream, BC.AsmInfo.get());
-    Ostream.flush();
-  }
-
-  Tag += MemRef.BaseRegNum != BC.MIB->getNoRegister()
-             ? "r" + to_string(MemRef.BaseRegNum)
-             : "";
-
-  Tag += MemRef.DispExpr ? "+" + DispExprStr : "+" + to_string(MemRef.DispImm);
-
-  Tag += MemRef.IndexRegNum != BC.MIB->getNoRegister()
-             ? "+" + to_string(MemRef.ScaleImm) + "*" +
-                   to_string(MemRef.IndexRegNum)
-             : "";
-
-  Tag += MemRef.SegRegNum != BC.MIB->getNoRegister()
-             ? "_seg_" + to_string(MemRef.SegRegNum)
-             : "";
+  TagOS << "mem_";
+
+  if (MemRef.BaseRegNum != BC.MIB->getNoRegister())
+    BC.InstPrinter->printRegName(TagOS, MemRef.BaseRegNum);
+
+  TagOS << "+";
+  if (MemRef.DispExpr)
+    MemRef.DispExpr->print(TagOS, BC.AsmInfo.get());
+  else
+    TagOS << MemRef.DispImm;
+
+  if (MemRef.IndexRegNum != BC.MIB->getNoRegister()) {
+    TagOS << "+" << MemRef.ScaleImm << "*";
+    BC.InstPrinter->printRegName(TagOS, MemRef.IndexRegNum);
+  }
+
+  if (MemRef.SegRegNum != BC.MIB->getNoRegister()) {
+    TagOS << "_seg_";
+    BC.InstPrinter->printRegName(TagOS, MemRef.SegRegNum);
+  }
 
+  TagOS.flush();
   return Tag;
 }
 
 BinaryFunction *RetpolineInsertion::getOrCreateRetpoline(
     BinaryContext &BC, const IndirectBranchInfo &BrInfo, bool R11Available) {
   const std::string RetpolineTag =
       createRetpolineFunctionTag(BC, BrInfo, R11Available);
 

bolt/test/CMakeLists.txt

list(APPEND BOLT_TEST_DEPS
   llvm-bat-dump
   llvm-dwarfdump
   llvm-dwp
   llvm-mc
   llvm-nm
   llvm-objdump
   llvm-readelf
   llvm-readobj
+  llvm-strings
   llvm-strip
   llvm-objcopy
   merge-fdata
   not
   perf2bolt
   split-file
   yaml2obj
   )

bolt/test/lit.cfg.py

tools = [
     ToolSubst('llvm-bolt-heatmap', unresolved='fatal'),
     ToolSubst('llvm-bat-dump', unresolved='fatal'),
     ToolSubst('perf2bolt', unresolved='fatal'),
     ToolSubst('yaml2obj', unresolved='fatal'),
     ToolSubst('llvm-mc', unresolved='fatal'),
     ToolSubst('llvm-nm', unresolved='fatal'),
     ToolSubst('llvm-objdump', unresolved='fatal'),
     ToolSubst('llvm-objcopy', unresolved='fatal'),
+    ToolSubst('llvm-strings', unresolved='fatal'),
     ToolSubst('llvm-strip', unresolved='fatal'),
     ToolSubst('llvm-readelf', unresolved='fatal'),
     ToolSubst('link_fdata', command=sys.executable, unresolved='fatal', extra_args=[link_fdata_cmd]),
     ToolSubst('merge-fdata', unresolved='fatal'),
     ToolSubst('llvm-readobj', unresolved='fatal'),
     ToolSubst('llvm-dwp', unresolved='fatal'),
     ToolSubst('split-file', unresolved='fatal'),
 ]

bolt/test/runtime/X86/retpoline-synthetic.test

 CHECK-JUMP-ORIG-NOT: jmpq   *
 
 # Check that there are no indirect calls or jumps in the resulting binary
 RUN: llvm-objdump -d %t | FileCheck %s -check-prefix=CHECK-CALL
 CHECK-CALL-NOT: callq  *
 RUN: llvm-objdump -d -j ".text" %t | FileCheck %s -check-prefix=CHECK-JUMP
 CHECK-JUMP-NOT: jmpq   *
 
+# Check generated retpoline stub names
+RUN: llvm-strings %t | FileCheck %s -check-prefix=CHECK-STRINGS
+CHECK-STRINGS-DAG: __retpoline_%rax_
+CHECK-STRINGS-DAG: __retpoline_mem_%rip+DATAat0x[[#]]
+CHECK-STRINGS-DAG: __retpoline_mem_%rax+0
+CHECK-STRINGS-DAG: __retpoline_mem_%r[[#]]+0+8*%rbx
+
 RUN: %t 1000 3 | FileCheck %s
 CHECK: 30000000