[3/3] TLS loads optimization (hoist)

[xiangzhangllvm]

Summary

We supported TLS loads optimization (LLVM part) at D120000

Now we enable it in PIC mode by default.

[LuoYuanke]

Can we extract the LLVM change to a separate patch? The LLVM change is obvious. We can leave the clang patch in discussion.

[xiangzhangllvm]

In D122866#3421845, @LuoYuanke wrote:

Can we extract the LLVM change to a separate patch? The LLVM change is obvious. We can leave the clang patch in discussion.

Done, I split the llvm (refine) part to D122890

[pengfei]

LGTM.

clang/lib/CodeGen/CGCall.cpp

void CodeGenModule::getDefaultFunctionAttributes(StringRef Name,
   }
 
   if (CodeGenOpts.DisableRedZone)
     FuncAttrs.addAttribute(llvm::Attribute::NoRedZone);
   if (CodeGenOpts.IndirectTlsSegRefs)
     FuncAttrs.addAttribute("indirect-tls-seg-refs");
   if (CodeGenOpts.NoImplicitFloat)
     FuncAttrs.addAttribute(llvm::Attribute::NoImplicitFloat);
+  if (Context.getLangOpts().PICLevel > 0)
+    FuncAttrs.addAttribute("tls-load-hoist");
 
   if (AttrOnCallSite) {
     // Attributes that should go on the call site only.
     if (!CodeGenOpts.SimplifyLibCalls || LangOpts.isNoBuiltinFunc(Name))
       FuncAttrs.addAttribute(llvm::Attribute::NoBuiltin);
     if (!CodeGenOpts.TrapFuncName.empty())
       FuncAttrs.addAttribute("trap-func-name", CodeGenOpts.TrapFuncName);
   } else {

clang/test/CodeGen/X86/tls_loads.cpp

+// RUN: %clang -target x86_64-unknown-unknown -fPIC -O2 -S -o - %s -emit-llvm | FileCheck %s --check-prefix=HOIST
+// RUN: %clang -target x86_64-unknown-unknown -O2 -S -o - %s -emit-llvm | FileCheck %s --check-prefix=NOHOIST
+
+// Use this test generate IR test for llvm/test/CodeGen/X86/intel-tls-loads-control*.ll
+thread_local int thl_x;
+thread_local int thl_x2;
+
+struct SS {
+  char thl_c;
+  int num;
+};
+
+int gfunc();
+int gfunc2(int);
+
+int f1(int c) {
+  int *px = &thl_x;
+  while (c--)
+    *px += gfunc2(thl_x2);
+  return *px;
+}
+
+int f2(int c) {
+  thread_local struct SS st;
+  while (c--) {
+    thl_x += gfunc();
+    st.thl_c += (char)gfunc();
+    st.num += gfunc();
+  }
+  return thl_x;
+}
+
+int f3(int c) {
+  int *px = &thl_x;
+  gfunc2(*px);
+  gfunc2(*px);
+  return 1;
+}
+
+// HOIST: attributes {{.*}}"tls-load-hoist"
+// HOIST: attributes {{.*}}"tls-load-hoist"
+// HOIST: attributes {{.*}}"tls-load-hoist"
+
+// NOHOIST-NOT: attributes {{.*}}"tls-load-hoist"

llvm/docs/LangRef.rst

 ``"thunk"``
     This attribute indicates that the function will delegate to some other
     function with a tail call. The prototype of a thunk should not be used for
     optimization purposes. The caller is expected to cast the thunk prototype to
     match the thunk target prototype.
 
 ``"tls-load-hoist"``
     This attribute indicates that the function will try to reduce redundant
-    tls address caculation by hoisting tls variable.
+    tls address calculation by hoisting tls variable.
 
 ``uwtable[(sync|async)]``
     This attribute indicates that the ABI being targeted requires that
     an unwind table entry be produced for this function even if we can
     show that no exceptions passes by it. This is normally the case for
     the ELF x86-64 abi, but it can be disabled for some compilation
     units. The optional parameter describes what kind of unwind tables
     to generate: ``sync`` for normal unwind tables, ``async`` for asynchronous

llvm/lib/Transforms/Scalar/TLSVariableHoist.cpp

 #include <tuple>
 #include <utility>
 
 using namespace llvm;
 using namespace tlshoist;
 
 #define DEBUG_TYPE "tlshoist"
 
-// TODO: Support "strict" model if we need to strictly load TLS address,
-// because "non-optimize" may also do some optimization in other passes.
-static cl::opt<std::string> TLSLoadHoist(
-    "tls-load-hoist",
-    cl::desc(
-        "hoist the TLS loads in PIC model: "
-        "tls-load-hoist=optimize: Eleminate redundant TLS load(s)."
-        "tls-load-hoist=strict: Strictly load TLS address before every use."
-        "tls-load-hoist=non-optimize: Generally load TLS before use(s)."),
-    cl::init("non-optimize"), cl::Hidden);
+static cl::opt<bool> TLSLoadHoist(
+    "tls-load-hoist", cl::init(false), cl::Hidden,
+    cl::desc("hoist the TLS loads in PIC model to eleminate redundant "
+             "TLS address calculation."));
 
 namespace {
 
 /// The TLS Variable hoist pass.
 class TLSVariableHoistLegacyPass : public FunctionPass {
 public:
   static char ID; // Pass identification, replacement for typeid
 

 }
 
 /// Optimize expensive TLS variables in the given function.
 bool TLSVariableHoistPass::runImpl(Function &Fn, DominatorTree &DT,
                                    LoopInfo &LI) {
   if (Fn.hasOptNone())
     return false;
 
-  if (TLSLoadHoist != "optimize" &&
-      !Fn.getAttributes().hasFnAttr("tls-load-hoist"))
+  if (!TLSLoadHoist && !Fn.getAttributes().hasFnAttr("tls-load-hoist"))
     return false;
 
   this->LI = &LI;
   this->DT = &DT;
   assert(this->LI && this->DT && "Unexcepted requirement!");
 
   // Collect all TLS variable candidates.
   collectTLSCandidates(Fn);

llvm/test/CodeGen/X86/tls-loads-control.ll

-; RUN: llc -mtriple=x86_64-unknown-unknown -O2 --relocation-model=pic --tls-load-hoist=optimize --stop-after=tlshoist -o - %s | FileCheck %s
+; RUN: llc -mtriple=x86_64-unknown-unknown -O2 --relocation-model=pic --tls-load-hoist=true --stop-after=tlshoist -o - %s | FileCheck %s
 ; RUN: llc -mtriple=x86_64-unknown-unknown -O2 --relocation-model=pic --stop-after=tlshoist -o - %s | FileCheck %s
 
 ; This test come from compiling clang/test/CodeGen/intel/tls_loads.cpp with:
 ; (clang tls_loads.cpp -fPIC -ftls-model=global-dynamic -O2 -S -emit-llvm)
 
 ; // Variable declaration and definition:
 ; thread_local int thl_x;
 ; thread_local int thl_x2;

llvm/test/CodeGen/X86/tls-loads-control2.ll

-; RUN: opt -S -mtriple=x86_64-unknown-unknown -tlshoist --relocation-model=pic --tls-load-hoist=optimize -o - %s | FileCheck %s --check-prefix=HOIST0
-; RUN: opt -S -mtriple=x86_64-unknown-unknown -tlshoist --relocation-model=pic --tls-load-hoist=non-optimize -o - %s | FileCheck %s --check-prefix=HOIST2
+; RUN: opt -S -mtriple=x86_64-unknown-unknown -tlshoist --relocation-model=pic --tls-load-hoist=true -o - %s | FileCheck %s --check-prefix=HOIST0
 ; RUN: opt -S -mtriple=x86_64-unknown-unknown -tlshoist --relocation-model=pic -o - %s | FileCheck %s --check-prefix=HOIST2
 
 $_ZTW5thl_x = comdat any
 
 @thl_x = thread_local global i32 0, align 4
 
 ; Function Attrs: mustprogress uwtable
 define i32 @_Z2f1i(i32 %c) local_unnamed_addr #0 {

llvm/test/CodeGen/X86/tls-loads-control3.ll

 ; NOTE: Assertions have been autogenerated by utils/update_llc_test_checks.py
-; RUN: llc -mtriple=x86_64-unknown-unknown -O2 --relocation-model=pic --tls-load-hoist=optimize -o - %s | FileCheck %s --check-prefix=HOIST0
-; RUN: llc -mtriple=x86_64-unknown-unknown -O2 --relocation-model=pic --tls-load-hoist=non-optimize -o - %s | FileCheck %s --check-prefix=HOIST2
+; RUN: llc -mtriple=x86_64-unknown-unknown -O2 --relocation-model=pic --tls-load-hoist=true -o - %s | FileCheck %s --check-prefix=HOIST0
 ; RUN: llc -mtriple=x86_64-unknown-unknown -O2 --relocation-model=pic -o - %s | FileCheck %s --check-prefix=HOIST2
 
 ; This test has no module flag {"tls-load-hoist", i32 0}, so use --tls-load-hoist=x
 ; to choose the way of loading thread_local address.
 
 ; This test come from compiling clang/test/CodeGen/intel/tls_loads.cpp with:
 ; (clang tls_loads.cpp -fPIC -ftls-model=global-dynamic -O2 -S -emit-llvm)