[X86] Don't fold negative offset into 32-bit absolute address (e.g. movl $foo-1, %eax)

[MaskRay]

Summary

When building abseil-cpp bin/absl_hash_test with Clang in -fno-pic
mode, an instruction like movl $foo-2147483648, $eax may be produced
(subtracting a number from the address of a static variable). If foo's
address is smaller than 2147483648, GNU ld/gold/LLD will error because
R_X86_64_32 cannot represent a negative value.

using absl::Hash;
struct NoOp {
  template < typename HashCode >
  friend HashCode AbslHashValue(HashCode , NoOp );
};
template <typename> class HashIntTest : public testing::Test {};
TYPED_TEST_SUITE_P(HashIntTest);
TYPED_TEST_P(HashIntTest, BasicUsage) {
  if (std::numeric_limits< TypeParam >::min )
    EXPECT_NE(Hash< NoOp >()({}),
              Hash< TypeParam >()(std::numeric_limits< TypeParam >::min()));
}
REGISTER_TYPED_TEST_CASE_P(HashIntTest, BasicUsage);
using IntTypes = testing::Types< int32_t>;
INSTANTIATE_TYPED_TEST_CASE_P(My, HashIntTest, IntTypes);

ld: error: hash_test.cc:(function (anonymous namespace)::gtest_suite_HashIntTest_::BasicUsage<int>::TestBody(): .text+0x4E472): relocation R_X86_64_32 out of range: 18446744071564237392 is not in [0, 4294967295]; references absl::hash_internal::HashState::kSeed

Actually any negative offset is not allowed because the symbol address
can be zero (e.g. set by -Wl,--defsym=foo=0). So disallow such folding.

[pengfei]

llvm/lib/Target/X86/X86ISelLowering.cpp

19110–19111

Maybe just need to add Offset >=0 && here?

[MaskRay]

Simplify

[pengfei]

LGTM.

[MaskRay]

Improve description

llvm/lib/Target/X86/X86ISelLowering.h

namespace llvm {
   /// Define some predicates that are used for node matching.
   namespace X86 {
     /// Returns true if Elt is a constant zero or floating point constant +0.0.
     bool isZeroNode(SDValue Elt);
 
     /// Returns true of the given offset can be
     /// fit into displacement field of the instruction.
     bool isOffsetSuitableForCodeModel(int64_t Offset, CodeModel::Model M,
-                                      bool hasSymbolicDisplacement = true);
+                                      bool hasSymbolicDisplacement);
 
     /// Determines whether the callee is required to pop its
     /// own arguments. Callee pop is necessary to support tail calls.
     bool isCalleePop(CallingConv::ID CallingConv,
                      bool is64Bit, bool IsVarArg, bool GuaranteeTCO);
 
     /// If Op is a constant whose elements are all the same constant or
     /// undefined, return true and return the constant value in \p SplatVal.

llvm/lib/Target/X86/X86ISelLowering.cpp

bool X86::isOffsetSuitableForCodeModel(int64_t Offset, CodeModel::Model M,
 
   // FIXME: Some tweaks might be needed for medium code model.
   if (M != CodeModel::Small && M != CodeModel::Kernel)
     return false;
 
   // For small code model we assume that latest object is 16MB before end of 31
   // bits boundary. We may also accept pretty large negative constants knowing
   // that all objects are in the positive half of address space.
-  if (M == CodeModel::Small && Offset < 16*1024*1024)
+  if (M == CodeModel::Small && Offset < 16 * 1024 * 1024)
     return true;
 
   // For kernel code model we know that all object resist in the negative half
   // of 32bits address space. We may not accept negative offsets, since they may
   // be just off and we may accept pretty large positive ones.
   if (M == CodeModel::Kernel && Offset >= 0)
     return true;
 
SDValue X86TargetLowering::LowerGlobalOrExternal(SDValue Op, SelectionDAG &DAG,
 
   CodeModel::Model M = DAG.getTarget().getCodeModel();
   auto PtrVT = getPointerTy(DAG.getDataLayout());
   SDValue Result;
 
   if (GV) {
     // Create a target global address if this is a global. If possible, fold the
     // offset into the global address reference. Otherwise, ADD it on later.
+    // Suppress the folding if Offset is negative: movl foo-1, %eax is not
+    // allowed because if the address of foo is 0, the ELF R_X86_64_32
+    // relocation will fail to link because the value cannot be negative.
     int64_t GlobalOffset = 0;
     if (OpFlags == X86II::MO_NO_FLAG &&
-        X86::isOffsetSuitableForCodeModel(Offset, M)) {
+        Offset >= 0 &&
+        X86::isOffsetSuitableForCodeModel(Offset, M, true)) {
       std::swap(GlobalOffset, Offset);
     }
     Result = DAG.getTargetGlobalAddress(GV, dl, PtrVT, GlobalOffset, OpFlags);
   } else {
     // If this is not a global address, this must be an external symbol.
     Result = DAG.getTargetExternalSymbol(ExternalSym, PtrVT, OpFlags);
   }
 

llvm/test/CodeGen/X86/fold-add.ll

 ; MSTATIC-NEXT:  retq
 ; MPIC-NEXT:     leaq _GLOBAL_OFFSET_TABLE_(%rip), %rax
 ; MPIC-NEXT:     movabsq $foo@GOTOFF, %rcx
 ; MPIC-NEXT:     leaq 1701208431(%rax,%rcx), %rax
 entry:
   ret i64 add (i64 ptrtoint (i32* @foo to i64), i64 1701208431)
 }
 
+;; Test we don't emit movl foo-1, %eax. ELF R_X86_64_32 does not allow
+;; a negative value.
 define dso_local i64 @neg_1() #0 {
 ; CHECK-LABEL: neg_1:
 ; CHECK:       # %bb.0:
-; STATIC-NEXT:   movl $foo-1, %eax
+; STATIC-NEXT:   leaq foo-1(%rip), %rax
 ; PIC-NEXT:      leaq foo-1(%rip), %rax
 ; MSTATIC-NEXT:  movabsq $foo, %rax
 ; MSTATIC-NEXT:  decq %rax
 ; MPIC-NEXT:     leaq _GLOBAL_OFFSET_TABLE_(%rip), %rax
 ; MPIC-NEXT:     movabsq $foo@GOTOFF, %rcx
 ; MPIC-NEXT:     leaq -1(%rax,%rcx), %rax
 entry:
   ret i64 add (i64 ptrtoint (i32* @foo to i64), i64 -1)
 }
 
 define dso_local i64 @neg_0x80000000() #0 {
 ; CHECK-LABEL: neg_0x80000000:
 ; CHECK:       # %bb.0:
-; STATIC-NEXT:   movl $foo-2147483648, %eax
+; STATIC-NEXT:   leaq foo-2147483648(%rip), %rax
 ; PIC-NEXT:      leaq foo-2147483648(%rip), %rax
 ; MSTATIC-NEXT:  movabsq $foo, %rax
 ; MSTATIC-NEXT:  addq $-2147483648, %rax
 ; MPIC-NEXT:     leaq _GLOBAL_OFFSET_TABLE_(%rip), %rax
 ; MPIC-NEXT:     movabsq $foo@GOTOFF, %rcx
 ; MPIC-NEXT:     leaq -2147483648(%rax,%rcx), %rax
 entry:
   ret i64 add (i64 ptrtoint (i32* @foo to i64), i64 -2147483648)