Support for the mno-tls-direct-seg-refs flag

[nruslan]

Summary

Allows to disable direct TLS segment access (%fs or %gs). GCC supports a similar flag, it can be useful in some circumstances, e.g. when a thread context block needs to be updated directly from user space. More info and specific use cases: https://bugs.llvm.org/show_bug.cgi?id=16145

There is another revision for clang as well.

Related: D53102

[hans]

Looks good to me. Craig should probably sign off too though.

lib/Target/X86/X86ISelDAGToDAG.cpp

168

nit: period at the end.

987

Looks very simple :-) I'm not really familiar with this, but I assume you've tested that it does the right thing.

test/CodeGen/X86/tls.ll

457

I know this file seems to go for brevity of function names, but I'd still suggest calling it something more descriptive, or adding a comment so it's more obvious to the reader what's going on.

[nruslan]

lib/Target/X86/X86ISelDAGToDAG.cpp

987

Yeah, it seems to pass tests. I also added one more test.

test/CodeGen/X86/tls.ll

457

added a comment there

[nruslan]

@hans , @craig.topper : I updated the LLVM patch as well to reflect all requested changes + added one more test case.

[craig.topper]

Should we have a test with -fast-isel as well? It looks like it might fallback to SelectionDAG when it sees TLS, but I'm not sure.

[nruslan]

@craig.topper : Do you mean adding a couple of more labels (x86/x64 Linux) in tls.ll with the -fast-isel option enabled and expanding these two new test cases?

[craig.topper]

In D53103#1262316, @nruslan wrote:

@craig.topper : Do you mean adding a couple of more labels (x86/x64 Linux) in tls.ll with the -fast-isel option enabled and expanding these two new test cases?

Yeah. That should work. Ideally it will generate the same code as not fast-isel and you won't need a new filecheck prefix, but we're probably not that lucky.

[nruslan]

In D53103#1262415, @craig.topper wrote:

In D53103#1262316, @nruslan wrote:

@craig.topper : Do you mean adding a couple of more labels (x86/x64 Linux) in tls.ll with the -fast-isel option enabled and expanding these two new test cases?

Yeah. That should work. Ideally it will generate the same code as not fast-isel and you won't need a new filecheck prefix, but we're probably not that lucky.

@craig.topper : I extended tests in the patch. Please take a look if that is what you have meant.

[nruslan]

new patch

[craig.topper]

LGTM

[nruslan]

@hans : is everything ok, can someone check it in?

[kristina]

In D53103#1265357, @nruslan wrote:

@hans : is everything ok, can someone check it in?

Seems good, let me build and run the tests on a buildbot and I'll commit it if it's all fine, as it's approved by the code owner for X86.

docs/LangRef.rst

``noinline``
     with the ``alwaysinline`` attribute.
 ``nonlazybind``
     This attribute suppresses lazy symbol binding for the function. This
     may make calls to the function faster, at the cost of extra program
     startup time if the function is not called during program startup.
 ``noredzone``
     This attribute indicates that the code generator should not use a
     red zone, even if the target-specific ABI normally permits it.
+``indirect-tls-seg-refs``
+    This attribute indicates that the code generator should not use
+    direct TLS access through segment registers, even if the
+    target-specific ABI normally permits it.
 ``noreturn``
     This function attribute indicates that the function never returns
     normally. This produces undefined behavior at runtime if the
     function ever does dynamically return.
 ``norecurse``
     This function attribute indicates that the function does not call itself
     either directly or indirectly down any possible call path. This produces
     undefined behavior at runtime if the function ever does recurse.

lib/Target/X86/X86ISelDAGToDAG.cpp

class X86DAGToDAGISel final : public SelectionDAGISel {
 
     /// If true, selector should try to optimize for code size instead of
     /// performance.
     bool OptForSize;
 
     /// If true, selector should try to optimize for minimum code size.
     bool OptForMinSize;
 
+    /// Disable direct TLS access through segment registers
+    bool IndirectTlsSegRefs;
+
   public:
     explicit X86DAGToDAGISel(X86TargetMachine &tm, CodeGenOpt::Level OptLevel)
         : SelectionDAGISel(tm, OptLevel), OptForSize(false),
           OptForMinSize(false) {}
 
     StringRef getPassName() const override {
       return "X86 DAG->DAG Instruction Selection";
     }
 
     bool runOnMachineFunction(MachineFunction &MF) override {
       // Reset the subtarget each time through.
       Subtarget = &MF.getSubtarget<X86Subtarget>();
+      IndirectTlsSegRefs = MF.getFunction().hasFnAttribute(
+                             "indirect-tls-seg-refs");
       SelectionDAGISel::runOnMachineFunction(MF);
       return true;
     }
 
     void EmitFunctionEntryCode() override;
 
     bool IsProfitableToFold(SDValue N, SDNode *U, SDNode *Root) const override;
 
bool X86DAGToDAGISel::matchLoadInAddress(LoadSDNode *N, X86ISelAddressMode &AM){
   // load gs:0 -> GS segment register.
   // load fs:0 -> FS segment register.
   //
   // This optimization is valid because the GNU TLS model defines that
   // gs:0 (or fs:0 on X86-64) contains its own address.
   // For more information see http://people.redhat.com/drepper/tls.pdf
   if (ConstantSDNode *C = dyn_cast<ConstantSDNode>(Address))
     if (C->getSExtValue() == 0 && AM.Segment.getNode() == nullptr &&
+        !IndirectTlsSegRefs &&
         (Subtarget->isTargetGlibc() || Subtarget->isTargetAndroid() ||
          Subtarget->isTargetFuchsia()))
       switch (N->getPointerInfo().getAddrSpace()) {
       case 256:
         AM.Segment = CurDAG->getRegister(X86::GS, MVT::i16);
         return false;
       case 257:
         AM.Segment = CurDAG->getRegister(X86::FS, MVT::i16);

test/CodeGen/X86/tls.ll

 
 ; X64_LINUX-LABEL: f16:
 ; X64_LINUX:       movq %fs:0, %rax
 ; X64_LINUX-NEXT:  leaq i6@TPOFF(%rax), %rax
 ; X64_LINUX-NEXT:  ret
 
   ret i32* @i6
 }
+
+define i32 @f17() #0 {
+; X86_LINUX-LABEL: f17:
+; X86_LINUX:      movl %gs:0, %eax
+; X86_LINUX-NEXT: movl i1@NTPOFF(%eax), %eax
+; X86_LINUX-NEXT: ret
+; X64_LINUX-LABEL: f17:
+; X64_LINUX:      movq %fs:0, %rax
+; X64_LINUX-NEXT: movl i1@TPOFF(%rax), %eax
+; X64_LINUX-NEXT: ret
+
+entry:
+  %tmp1 = load i32, i32* @i1
+  ret i32 %tmp1
+}
+
+attributes #0 = { "indirect-tls-seg-refs" }