Fix global variable addressing code generation issue in PIC medium code model

[Jianping]

Summary

This is to fix the bug on PIC medium code model for global variable addressing.
without this patch,
llc -filetype=asm -code-model=medium -relocation-model=pic x86-64-pic-medium-codemodel.ll –o x86-64-pic-medium-codemodel.s
will report error like
error: 32 bit reloc applied to a field with a different size

movabsq $x@GOTPCREL, %rax
^

X86DAGToDAGISel::matchWrapper, X86::isOffsetSuitableForCodeModel and X86TargetLowering::getGlobalWrapperKind didn't handle the wrapperRIP for medium code model correctly. This patch is fixed this.

[rnk]

I have this change as part of https://reviews.llvm.org/D47211, which I'll try to reland soon.

[craig.topper]

@rnk, I see that this patch touches isOffsetSuitableForCodeModel , but D47211 does not.

[rnk]

In D48417#1141304, @craig.topper wrote:

@rnk, I see that this patch touches isOffsetSuitableForCodeModel , but D47211 does not.

I think this change implements some extra folding that would only be appropriate once we have heuristics in place for classifying "near" and "far" globals. I was thinking we'd implement the logic for classifying globals in clang, since we'll probably want both explicit attributes and size cutoffs, and that we'd mark "near" globals, and unadorned globals would always be treated as far away, requiring GOTPCREL or GOTOFF64 relocations, depending on whether they are known to be dso_local or not.

test/CodeGen/X86/x86-64-codemodel-medium-internal.ll

21–22

This doesn't seem correct. global_arr might be too far away, right?

[Jianping]

In D48417#1140801, @rnk wrote:

I have this change as part of https://reviews.llvm.org/D47211, which I'll try to reland soon.

I re-check again with the latest LLVM codes, this one is the minimal modification to fix the compilation error exposed here.
Once your codes check-in, I think I can abandon this revision.
Thanks

test/CodeGen/X86/x86-64-codemodel-medium-internal.ll

21–22

current LLVM codes will generate the code like this. Because you have enhanced the medium and large code model implementation, this test case need to be removed to reflect more correct result. Thanks

lib/Target/X86/X86ISelDAGToDAG.cpp

bool X86DAGToDAGISel::matchWrapper(SDValue N, X86ISelAddressMode &AM) {
   // If the addressing mode already has a symbol as the displacement, we can
   // never match another symbol.
   if (AM.hasSymbolicDisplacement())
     return true;
 
   bool IsRIPRel = N.getOpcode() == X86ISD::WrapperRIP;
 
   // Only do this address mode folding for 64-bit if we're in the small code
-  // model.
-  // FIXME: But we can do GOTPCREL addressing in the medium code model.
+  // model or medium code model.
   CodeModel::Model M = TM.getCodeModel();
-  if (Subtarget->is64Bit() && M != CodeModel::Small && M != CodeModel::Kernel)
+  if (Subtarget->is64Bit() && M != CodeModel::Small && M != CodeModel::Kernel
+      && !(M == CodeModel::Medium && IsRIPRel) ) {
       return true;
+  }
 
   // Base and index reg must be 0 in order to use %rip as base.
   if (IsRIPRel && AM.hasBaseOrIndexReg())
     return true;
 
   // Make a local copy in case we can't do this fold.
   X86ISelAddressMode Backup = AM;
 

lib/Target/X86/X86ISelLowering.cpp

bool X86::isOffsetSuitableForCodeModel(int64_t Offset, CodeModel::Model M,
   if (!isInt<32>(Offset))
     return false;
 
   // If we don't have a symbolic displacement - we don't have any extra
   // restrictions.
   if (!hasSymbolicDisplacement)
     return true;
 
-  // FIXME: Some tweaks might be needed for medium code model.
-  if (M != CodeModel::Small && M != CodeModel::Kernel)
+  if (M != CodeModel::Small && M != CodeModel::Medium && 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)
+  // For small and medium 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 || M == CodeModel::Medium)
+      && 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;
 

 unsigned X86TargetLowering::getGlobalWrapperKind(
     const GlobalValue *GV, const unsigned char OpFlags) const {
   // References to absolute symbols are never PC-relative.
   if (GV && GV->isAbsoluteSymbolRef())
     return X86ISD::Wrapper;
 
   CodeModel::Model M = getTargetMachine().getCodeModel();
   if (Subtarget.isPICStyleRIPRel() &&
-      (M == CodeModel::Small || M == CodeModel::Kernel))
+      (M == CodeModel::Small || M == CodeModel::Medium || M == CodeModel::Kernel))
     return X86ISD::WrapperRIP;
 
   // GOTPCREL references must always use RIP.
   if (OpFlags == X86II::MO_GOTPCREL)
     return X86ISD::WrapperRIP;
 
   return X86ISD::Wrapper;
 }

test/CodeGen/X86/x86-64-codemodel-medium-external.ll

+; RUN: llc < %s -code-model=medium -relocation-model=pic | FileCheck -check-prefix CHECK-MEDIUM-PIC %s
+; RUN: llc < %s -code-model=medium | FileCheck -check-prefix CHECK-MEDIUM %s
+
+target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128"
+target triple = "x86_64-unknown-linux-gnu"
+
+;This is to test the external global access under PIC/no-PIC medium code model
+;with different size and offset. This is to enusre the modification not break i
+;the other code path on handling the medium code model
+;
+;for medium code model,
+; Small symbols are also assumed to be linked into the low 2GB
+; Symbols with sizes larger than -mlarge-data-threshold
+;  are put into large data or bss sections and can be located above 2GB
+; Data is considered large when it's larger than large-data-threshold,
+;  which is 64KB by default
+; on PIC, both generate the same addressing mode
+
+@global_arr = external global [100 x i32], align 16
+@t = external global i32, align 4
+@global_arr_big = external global [50000 x i32], align 16
+
+@x1 = external global [8388608 x i32], align 16
+
+define i32 @f_offset_gt_16M() {
+entry:
+; CHECK-MEDIUM-PIC-LABEL: f_offset_gt_16M:
+; CHECK-MEDIUM-PIC:  movq    x1@GOTPCREL(%rip), %rax
+; CHECK-MEDIUM-PIC:  movl    20971520(%rax), %eax
+; CHECK-MEDIUM-LABEL:  f_offset_gt_16M:
+; CHECK-MEDIUM:  movabsq $x1, %rax
+; CHECK-MEDIUM:  movl    20971520(%rax), %eax
+  %0 = load i32, i32* getelementptr inbounds ([8388608 x i32], [8388608 x i32]* @x1, i64 0, i64 5242880), align 16
+  ret i32 %0
+}
+
+;This is for small data
+define i32 @foo() {
+entry:
+; CHECK-MEDIUM-PIC-LABEL:  foo:
+; CHECK-MEDIUM-PIC:  movq    global_arr@GOTPCREL(%rip),
+; CHECK-MEDIUM-LABEL:  foo:
+; CHECK-MEDIUM:  movabsq $global_arr+28,
+  %0 = load i32, i32* getelementptr inbounds ([100 x i32], [100 x i32]* @global_arr, i64 0, i64 7), align 4
+  %1 = load i32, i32* @t, align 4
+  %add = add nsw i32 %1, %0
+  store i32 %add, i32* @t, align 4
+  %2 = load i32, i32* @t, align 4
+  ret i32 %2
+}
+
+;This is for big data
+define i32 @main() {
+entry:
+; CHECK-MEDIUM-PIC-LABEL:  main:
+; CHECK-MEDIUM-PIC:  movq    global_arr_big@GOTPCREL(%rip),
+; CHECK-MEDIUM-LABEL:  main:
+; CHECK-MEDIUM:  movabsq $global_arr_big+28,
+  %retval = alloca i32, align 4
+  store i32 0, i32* %retval, align 4
+  %call = call i32 @foo()
+  %0 = load i32, i32* @t, align 4
+  %add = add nsw i32 %0, %call
+  store i32 %add, i32* @t, align 4
+  %1 = load i32, i32* getelementptr inbounds ([50000 x i32], [50000 x i32]* @global_arr_big, i64 0, i64 7), align 4
+  %2 = load i32, i32* @t, align 4
+  %add1 = add nsw i32 %2, %1
+  store i32 %add1, i32* @t, align 4
+  %3 = load i32, i32* @t, align 4
+  ret i32 %3
+}

test/CodeGen/X86/x86-64-codemodel-medium-internal.ll

+; RUN: llc < %s -code-model=medium | FileCheck -check-prefix CHECK-MEDIUM %s
+; RUN: llc < %s -code-model=medium -relocation-model=pic | FileCheck -check-prefix CHECK-MEDIUM-PIC %s
+
+target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128"
+target triple = "x86_64-unknown-linux-gnu"
+
+;This is to test the internal global access under PIC/no-PIC medium code model
+;with different sizes
+;This is to ensure the current modification not break the other code path on
+;medium code model handling
+;
+
+@global_arr = internal global <{ i32, i32, [98 x i32] }> <{ i32 2, i32 3, [98 x i32] zeroinitializer }>, align 16
+@global_arr_big = internal global <{ i32, i32, [49998 x i32] }> <{ i32 5, i32 6, [49998 x i32] zeroinitializer }>, align 16
+@t = external dso_local global i32, align 4
+
+define i32 @foo() {
+entry:
+; CHECK-MEDIUM-LABEL:  foo:
+; CHECK-MEDIUM:   movabsq $global_arr+28,
+; CHECK-MEDIUM-PIC-LABEL:  foo:
+; CHECK-MEDIUM-PIC:  addl global_arr+28(%rip),
+  %0 = load i32, i32* getelementptr inbounds ([100 x i32], [100 x i32]* bitcast (<{ i32, i32, [98 x i32] }>* @global_arr to [100 x i32]*), i64 0, i64 7), align 4
+  %1 = load i32, i32* @t, align 4
+  %add = add nsw i32 %1, %0
+  store i32 %add, i32* @t, align 4
+  %2 = load i32, i32* @t, align 4
+  ret i32 %2
+}
+
+define i32 @foo_big() {
+entry:
+; CHECK-MEDIUM-LABEL:  foo_big:
+; CHECK-MEDIUM:   movabsq $global_arr_big+28,
+; CHECK-MEDIUM-PIC-LABEL:  foo_big:
+; CHECK-MEDIUM-PIC:  addl global_arr_big+28(%rip),
+  %0 = load i32, i32* getelementptr inbounds ([50000 x i32], [50000 x i32]* bitcast (<{ i32, i32, [49998 x i32] }>* @global_arr_big to [50000 x i32]*), i64 0, i64 7), align 4
+  %1 = load i32, i32* @t, align 4
+  %add = add nsw i32 %1, %0
+  store i32 %add, i32* @t, align 4
+  %2 = load i32, i32* @t, align 4
+  ret i32 %2
+}

test/CodeGen/X86/x86-64-pic-medium-codemodel.ll

+; RUN: llc < %s -code-model=medium -relocation-model=pic | FileCheck -check-prefix CHECK-MEDIUM %s
+; RUN: llc < %s -code-model=small -relocation-model=pic | FileCheck -check-prefix CHECK-SMALL %s
+
+; This is to test the common global addressing in PIC medium code model
+; The addressing codes should same as the PIC small code model
+; Test one scalar type global variable x
+
+target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128"
+target triple = "x86_64-unknown-linux-gnu"
+
+@x = common global i32* null, align 8
+
+define i32 @bar() {
+entry:
+; CHECK-MEDIUM-LABEL:  bar:
+; CHECK-MEDIUM:   movq    x@GOTPCREL(%rip), %rax
+; CHECK-SMALL-LABEL:  bar:
+; CHECK-SAMLL:   movq    x@GOTPCREL(%rip), %rax
+  %retval = alloca i32, align 4
+  store i32 0, i32* %retval, align 4
+  %0 = load i32*, i32** @x, align 8
+  call void @foo(i32* %0)
+  ret i32 0
+}
+
+declare void @foo(i32*)