[AArch64][GlobalISel] Don't match thread-local globals in matchFoldGlobalOffset

[paquette]

Summary

SelectionDAG has separate ISD opcodes for regular global values and thread-local global values, while GlobalISel does not.

This combine was ported from SDAG directly without knowing that. As a result, it was running on TLS globals.

This makes it so that matchFoldGlobalOffset doesn't match on TLS globals, and adds an assert to selectTLSGlobalValue to make sure that TLS globals never have offsets.

[aemerson]

Wow, that was a nasty one. Thanks for tracking it down. LGTM.

llvm/lib/Target/AArch64/GISel/AArch64InstructionSelector.cpp

 
 bool AArch64InstructionSelector::selectTLSGlobalValue(
     MachineInstr &I, MachineRegisterInfo &MRI) const {
   if (!STI.isTargetMachO())
     return false;
   MachineFunction &MF = *I.getParent()->getParent();
   MF.getFrameInfo().setAdjustsStack(true);
 
-  const GlobalValue &GV = *I.getOperand(1).getGlobal();
+  const auto &GlobalOp = I.getOperand(1);
+  assert(GlobalOp.getOffset() == 0 &&
+         "Shouldn't have an offset on TLS globals!");
+  const GlobalValue &GV = *GlobalOp.getGlobal();
   MachineIRBuilder MIB(I);
 
   auto LoadGOT =
       MIB.buildInstr(AArch64::LOADgot, {&AArch64::GPR64commonRegClass}, {})
           .addGlobalAddress(&GV, 0, AArch64II::MO_TLS);
 
   auto Load = MIB.buildInstr(AArch64::LDRXui, {&AArch64::GPR64commonRegClass},
                              {LoadGOT.getReg(0)})

llvm/lib/Target/AArch64/GISel/AArch64PreLegalizerCombiner.cpp

 ///
 /// %g = G_GLOBAL_VALUE @x -> %g = G_GLOBAL_VALUE @x + cst
 static bool matchFoldGlobalOffset(MachineInstr &MI, MachineRegisterInfo &MRI,
                                   std::pair<uint64_t, uint64_t> &MatchInfo) {
   assert(MI.getOpcode() == TargetOpcode::G_GLOBAL_VALUE);
   MachineFunction &MF = *MI.getMF();
   auto &GlobalOp = MI.getOperand(1);
   auto *GV = GlobalOp.getGlobal();
+  if (GV->isThreadLocal())
+    return false;
 
   // Don't allow anything that could represent offsets etc.
   if (MF.getSubtarget<AArch64Subtarget>().ClassifyGlobalReference(
           GV, MF.getTarget()) != AArch64II::MO_NO_FLAG)
     return false;
 
   // Look for a G_GLOBAL_VALUE only used by G_PTR_ADDs against constants:
   //

llvm/test/CodeGen/AArch64/GlobalISel/fold-global-offsets.mir

 # NOTE: Assertions have been autogenerated by utils/update_mir_test_checks.py
 # RUN: llc -mtriple aarch64-apple-darwin -run-pass=aarch64-prelegalizer-combiner -verify-machineinstrs %s -o - | FileCheck %s
 
 --- |
     @g = external hidden global i32
 
     %opaque = type opaque
     @unsized = external hidden global %opaque
+    @thread_local = thread_local global i32 0
 
     define void @one_ptr_add() { ret void }
     define void @add_to_offset() { ret void }
     define void @two_ptr_adds_same_offset() { ret void }
     define void @two_ptr_adds_different_offset() { ret void }
     define void @ptr_add_chain() { ret void }
 
     define void @dont_fold_negative_offset() { ret void }
     define void @dont_min_offset_less_than_curr_offset() { ret void }
     define void @dont_fold_max_offset() { ret void }
     define void @dont_fold_offset_larger_than_type_alloc() { ret void }
     define void @dont_fold_unsized_type() { ret void }
+    define void @dont_fold_thread_local() { ret void }
 ...
 ---
 name:            one_ptr_add
 alignment:       4
 tracksRegLiveness: true
 machineFunctionInfo: {}
 body:             |
   bb.0:
bb.0:
     ; CHECK: %ptr_add:_(p0) = G_PTR_ADD %global, %offset(s64)
     ; CHECK: $x0 = COPY %ptr_add(p0)
     ; CHECK: RET_ReallyLR implicit $x0
     %global:_(p0) = G_GLOBAL_VALUE @unsized
     %offset:_(s64) = G_CONSTANT i64 16
     %ptr_add:_(p0) = G_PTR_ADD %global, %offset(s64)
     $x0 = COPY %ptr_add(p0)
     RET_ReallyLR implicit $x0
+
+...
+---
+name:            dont_fold_thread_local
+alignment:       4
+tracksRegLiveness: true
+machineFunctionInfo: {}
+body:             |
+  bb.0:
+    ; Check that we don't touch thread-local globals.
+
+    ; CHECK-LABEL: name: dont_fold_thread_local
+    ; CHECK: %global:_(p0) = G_GLOBAL_VALUE @thread_local
+    ; CHECK: %offset:_(s64) = G_CONSTANT i64 16
+    ; CHECK: %ptr_add:_(p0) = G_PTR_ADD %global, %offset(s64)
+    ; CHECK: $x0 = COPY %ptr_add(p0)
+    ; CHECK: RET_ReallyLR implicit $x0
+    %global:_(p0) = G_GLOBAL_VALUE @thread_local
+    %offset:_(s64) = G_CONSTANT i64 16
+    %ptr_add:_(p0) = G_PTR_ADD %global, %offset(s64)
+    $x0 = COPY %ptr_add(p0)
+    RET_ReallyLR implicit $x0