IR, X86: Understand !range metadata on global variables.

[pcc]

Summary

Attaching !range to a global variable does two things:

1. Marks it as an absolute symbol reference.
2. Specifies the value range of that symbol's address.

Teach the X86 backend to allow absolute symbols to appear in place of
immediates by extending the relocImm and mov64imm32 matchers. Start using
relocImm in more places where it is legal.

As previously proposed on llvm-dev:
http://lists.llvm.org/pipermail/llvm-dev/2016-October/105800.html

Depends on D25812

Depends on D25862

Depends on D25877

[efriedma]

The IR representation you're using in your testcases is abusing the meaning of a global variable. You're declaring "variables" whose address doesn't actually correspond to an object in memory. In addition to being ugly, this could have nasty implications for alias analysis: we assume that global variables don't alias each other. (See llvm::isIdentifiedObject etc.)

Some sort of GlobalConstant might make sense if the code patterns from your testcases are useful.

[pcc]

The IR representation you're using in your testcases is abusing the meaning of a global variable.

Yes, I think this is certainly one of the downsides of this representation.

we assume that global variables don't alias each other. (See llvm::isIdentifiedObject etc.)

Orthogonally: this assumption doesn't seem sound in general. An object file may define multiple external symbols with the same address (e.g. using GlobalAlias) which may be referenced using separate external GlobalVariables.

Some sort of GlobalConstant might make sense if the code patterns from your testcases are useful.

Maybe. I'm not sure how feasible that approach would be though. I'll experiment with it a little and see.

[lattner]

I think there are two things going on here. I think that eli is right: LLVM IR global variables should always be assumable that they don't alias. This is guaranteed by C and other source languages and is important for LLVM to be able to represent. Separately though, I think it makes sense for LLVM globals to have !range metadata to specify that (though disjoint) they live in a specific address range that can fit into immediates.

There is a degenerate case where a global has a known address (either through magic knowledge by the frontend, or by a clang attribute, or by the compiler somehow knowing about a linker map in flight, e.g. with LTO) can be either represented with a specific !range metadata or with a new GlobalConstant address. I think it would be better to discuss such significant IR changes on llvmdev though.

[pcc]

• Update LangRef
• May not assume that absolute symbol refs are non-null

[pcc]

As discussed on the llvm-dev thread, we're going with the approach in this patch. I've updated the langref and added a nonnull check analogous to what I did in D25930.

Adding X86 reviewers to take a look at the X86-specific bits of this.

[craig.topper]

llvm/lib/Target/X86/X86ISelDAGToDAG.cpp

1725

This code WasTruncated stuff could probably use some comments explaining it.

1741

Were the 7 different opcode checks we had before significant? It safe to replace them with this single check for TargetGlobalAddress?

[pcc]

• Add more comments

llvm/lib/Target/X86/X86ISelDAGToDAG.cpp

1725

Added more comments here and in the rest of this function.

1741

I looked at all places where we create X86ISD::Wrapper nodes by following links from http://llvm-cs.pcc.me.uk/lib/Target/X86/X86ISelLowering.h/rWrapper

My conclusion was that I believe that it is only possible for us to have these 7 nodes as operands of X86ISD::Wrapper.

We can make this simplification separately; I've sent out D26731.

[pcc]

Refresh

[pcc]

Ping.

[efriedma]

llvm/docs/LangRef.rst

4579

This is sort of nitpicking, but could we call this something other than !range? Maybe !absolute_symbol? It's very different from the other uses of range metadata, given that it has mandatory effects on code generation.

[pcc]

llvm/docs/LangRef.rst

4579

Seems reasonable, will do.

[pcc]

• Rename metadata to absolute_symbol

[pcc]

(I'll s/range/absolute_symbol/g in the commit message when I commit, don't want to break the thread by changing it now.)

[efriedma]

The IR changes look fine; someone else should probably review the backend changes.

[pcc]

Thanks Eli. @craig.topper do the backend changes look good now?

[craig.topper]

Backend changes LGTM.

llvm/docs/LangRef.rst

.. code-block:: llvm
 
     !0 = !{ float 2.5 } ; maximum acceptable inaccuracy is 2.5 ULPs
 
 .. _range-metadata:
 
 '``range``' Metadata
 ^^^^^^^^^^^^^^^^^^^^
 
-``range`` metadata may be attached only to ``load``, ``call`` and ``invoke`` of
+``range`` metadata may be attached to ``load``, ``call`` and ``invoke`` of
 integer types. It expresses the possible ranges the loaded value or the value
 returned by the called function at this call site is in. The ranges are
 represented with a flattened list of integers. The loaded value or the value
 returned is known to be in the union of the ranges defined by each consecutive
 pair. Each pair has the following properties:
 
 -  The type must match the type loaded by the instruction.
 -  The pair ``a,b`` represents the range ``[a,b)``.
 -  Both ``a`` and ``b`` are constants.
 -  The range is allowed to wrap.
 -  The range should not represent the full or empty set. That is,
    ``a!=b``.
 
 In addition, the pairs must be in signed order of the lower bound and
 they must be non-contiguous.
 
+``range`` may also be attached to a global variable declaration. It marks the
+declaration as a reference to an absolute symbol, which causes the backend to
+use absolute relocations for the symbol even in position independent code,
+and expresses the possible ranges that the global variable's *address*
+(not its value) is in.
+
 Examples:
 
 .. code-block:: llvm
 
       %a = load i8, i8* %x, align 1, !range !0 ; Can only be 0 or 1
       %b = load i8, i8* %y, align 1, !range !1 ; Can only be 255 (-1), 0 or 1
       %c = call i8 @foo(),       !range !2 ; Can only be 0, 1, 3, 4 or 5
       %d = invoke i8 @bar() to label %cont
              unwind label %lpad, !range !3 ; Can only be -2, -1, 3, 4 or 5
+
+      @e = external global i8, !range !4 ; Can only have an address in range [0,256)
+
     ...
     !0 = !{ i8 0, i8 2 }
     !1 = !{ i8 255, i8 2 }
     !2 = !{ i8 0, i8 2, i8 3, i8 6 }
     !3 = !{ i8 -2, i8 0, i8 3, i8 6 }
+    !4 = !{ i64 0, i64 256 }
 
 '``unpredictable``' Metadata
 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
 ``unpredictable`` metadata may be attached to any branch or switch
 instruction. It can be used to express the unpredictability of control
 flow. Similar to the llvm.expect intrinsic, it may be used to alter
 optimizations related to compare and branch instructions. The metadata

llvm/include/llvm/IR/GlobalValue.h

 
 #include "llvm/IR/Constant.h"
 #include "llvm/IR/DerivedTypes.h"
 #include "llvm/Support/MD5.h"
 
 namespace llvm {
 
 class Comdat;
+class ConstantRange;
 class Error;
 class GlobalObject;
 class PointerType;
 class Module;
 
 namespace Intrinsic {
   enum ID : unsigned;
 }
/// @}
   // increased.
   bool canIncreaseAlignment() const;
 
   const GlobalObject *getBaseObject() const {
     return const_cast<GlobalValue *>(this)->getBaseObject();
   }
   GlobalObject *getBaseObject();
 
+  /// Returns whether this is a reference to an absolute symbol.
+  bool isAbsoluteSymbolRef() const;
+
+  /// If this is an absolute symbol reference, returns the range of the symbol,
+  /// otherwise returns None.
+  Optional<ConstantRange> getAbsoluteSymbolRange() const;
+
   /// This method unlinks 'this' from the containing module, but does not delete
   /// it.
   virtual void removeFromParent() = 0;
 
   /// This method unlinks 'this' from the containing module and deletes it.
   virtual void eraseFromParent() = 0;
 
   /// Get the module that this global value is contained inside of...

llvm/lib/Analysis/ValueTracking.cpp

bool llvm::isKnownNonNull(const Value *V) {
 
   // Alloca never returns null, malloc might.
   if (isa<AllocaInst>(V)) return true;
 
   // A byval, inalloca, or nonnull argument is never null.
   if (const Argument *A = dyn_cast<Argument>(V))
     return A->hasByValOrInAllocaAttr() || A->hasNonNullAttr();
 
-  // A global variable in address space 0 is non null unless extern weak.
-  // Other address spaces may have null as a valid address for a global,
-  // so we can't assume anything.
+  // A global variable in address space 0 is non null unless extern weak
+  // or an absolute symbol reference. Other address spaces may have null as a
+  // valid address for a global, so we can't assume anything.
   if (const GlobalValue *GV = dyn_cast<GlobalValue>(V))
-    return !GV->hasExternalWeakLinkage() &&
+    return !GV->isAbsoluteSymbolRef() && !GV->hasExternalWeakLinkage() &&
            GV->getType()->getAddressSpace() == 0;
 
   // A Load tagged with nonnull metadata is never null.
   if (const LoadInst *LI = dyn_cast<LoadInst>(V))
     return LI->getMetadata(LLVMContext::MD_nonnull);
 
   if (auto CS = ImmutableCallSite(V))
     if (CS.isReturnNonNull())

llvm/lib/IR/Globals.cpp

 // This file implements the GlobalValue & GlobalVariable classes for the IR
 // library.
 //
 //===----------------------------------------------------------------------===//
 
 #include "llvm/ADT/SmallPtrSet.h"
 #include "llvm/ADT/Triple.h"
 #include "llvm/IR/Constants.h"
+#include "llvm/IR/ConstantRange.h"
 #include "llvm/IR/DerivedTypes.h"
 #include "llvm/IR/GlobalAlias.h"
 #include "llvm/IR/GlobalValue.h"
 #include "llvm/IR/GlobalVariable.h"
 #include "llvm/IR/Module.h"
 #include "llvm/IR/Operator.h"
 #include "llvm/Support/Error.h"
 #include "llvm/Support/ErrorHandling.h"

 GlobalObject *GlobalValue::getBaseObject() {
   if (auto *GO = dyn_cast<GlobalObject>(this))
     return GO;
   if (auto *GA = dyn_cast<GlobalAlias>(this))
     return GA->getBaseObject();
   return nullptr;
 }
 
+bool GlobalValue::isAbsoluteSymbolRef() const {
+  auto *GO = dyn_cast<GlobalObject>(this);
+  if (!GO)
+    return false;
+
+  return GO->getMetadata(LLVMContext::MD_range);
+}
+
+Optional<ConstantRange> GlobalValue::getAbsoluteSymbolRange() const {
+  auto *GO = dyn_cast<GlobalObject>(this);
+  if (!GO)
+    return None;
+
+  MDNode *MD = GO->getMetadata(LLVMContext::MD_range);
+  if (!MD)
+    return None;
+
+  return getConstantRangeFromMetadata(*MD);
+}
+
 //===----------------------------------------------------------------------===//
 // GlobalVariable Implementation
 //===----------------------------------------------------------------------===//
 
 GlobalVariable::GlobalVariable(Type *Ty, bool constant, LinkageTypes Link,
                                Constant *InitVal, const Twine &Name,
                                ThreadLocalMode TLMode, unsigned AddressSpace,
                                bool isExternallyInitialized)

llvm/lib/Target/X86/X86ISelDAGToDAG.cpp

 #include "X86Subtarget.h"
 #include "X86TargetMachine.h"
 #include "llvm/ADT/Statistic.h"
 #include "llvm/CodeGen/MachineFrameInfo.h"
 #include "llvm/CodeGen/MachineFunction.h"
 #include "llvm/CodeGen/MachineInstrBuilder.h"
 #include "llvm/CodeGen/MachineRegisterInfo.h"
 #include "llvm/CodeGen/SelectionDAGISel.h"
+#include "llvm/IR/ConstantRange.h"
 #include "llvm/IR/Function.h"
 #include "llvm/IR/Instructions.h"
 #include "llvm/IR/Intrinsics.h"
 #include "llvm/IR/Type.h"
 #include "llvm/Support/Debug.h"
 #include "llvm/Support/ErrorHandling.h"
 #include "llvm/Support/MathExtras.h"
 #include "llvm/Support/raw_ostream.h"
if (N->getOpcode() != ISD::TargetConstantPool &&
       N->getOpcode() != ISD::TargetJumpTable &&
       N->getOpcode() != ISD::TargetGlobalAddress &&
       N->getOpcode() != ISD::TargetExternalSymbol &&
       N->getOpcode() != ISD::MCSymbol &&
       N->getOpcode() != ISD::TargetBlockAddress)
     return false;
 
   Imm = N;
+  if (N->getOpcode() != ISD::TargetGlobalAddress)
     return TM.getCodeModel() == CodeModel::Small;
+
+  Optional<ConstantRange> CR =
+      cast<GlobalAddressSDNode>(N)->getGlobal()->getAbsoluteSymbolRange();
+  if (!CR)
+    return TM.getCodeModel() == CodeModel::Small;
+
+  return CR->getUnsignedMax().ult(1ull << 32);
 }
 
 bool X86DAGToDAGISel::selectLEA64_32Addr(SDValue N, SDValue &Base,
                                          SDValue &Scale, SDValue &Index,
                                          SDValue &Disp, SDValue &Segment) {
   // Save the debug loc before calling selectLEAAddr, in case it invalidates N.
   SDLoc DL(N);
 

 
 bool X86DAGToDAGISel::selectRelocImm(SDValue N, SDValue &Op) {
   if (auto *CN = dyn_cast<ConstantSDNode>(N)) {
     Op = CurDAG->getTargetConstant(CN->getAPIntValue(), SDLoc(CN),
                                    N.getValueType());
     return true;
   }
 
+  // Keep track of the original value type and whether this value was
+  // truncated. If we see a truncation from pointer type to VT that truncates
+  // bits that are known to be zero, we can use a narrow reference.
+  EVT VT = N.getValueType();
+  bool WasTruncated = false;
+  if (N.getOpcode() == ISD::TRUNCATE) {
+    WasTruncated = true;
+    N = N.getOperand(0);
+  }
+
   if (N.getOpcode() != X86ISD::Wrapper)
     return false;
 
+  // We can only use non-GlobalValues as immediates if they were not truncated,
+  // as we do not have any range information. If we have a GlobalValue and the
+  // address was not truncated, we can select it as an operand directly.
   unsigned Opc = N.getOperand(0)->getOpcode();
-  if (Opc == ISD::TargetConstantPool || Opc == ISD::TargetJumpTable ||
-      Opc == ISD::TargetExternalSymbol || Opc == ISD::TargetGlobalAddress ||
-      Opc == ISD::TargetGlobalTLSAddress || Opc == ISD::MCSymbol ||
-      Opc == ISD::TargetBlockAddress) {
+  if (Opc != ISD::TargetGlobalAddress || !WasTruncated) {
     Op = N.getOperand(0);
-    return true;
+    // We can only select the operand directly if we didn't have to look past a
+    // truncate.
+    return !WasTruncated;
   }
 
+  // Check that the global's range fits into VT.
+  auto *GA = cast<GlobalAddressSDNode>(N.getOperand(0));
+  Optional<ConstantRange> CR = GA->getGlobal()->getAbsoluteSymbolRange();
+  if (!CR || CR->getUnsignedMax().uge(1ull << VT.getSizeInBits()))
     return false;
+
+  // Okay, we can use a narrow reference.
+  Op = CurDAG->getTargetGlobalAddress(GA->getGlobal(), SDLoc(N), VT,
+                                      GA->getOffset(), GA->getTargetFlags());
+  return true;
 }
 
 bool X86DAGToDAGISel::tryFoldLoad(SDNode *P, SDValue N,
                                   SDValue &Base, SDValue &Scale,
                                   SDValue &Index, SDValue &Disp,
                                   SDValue &Segment) {
   if (!ISD::isNON_EXTLoad(N.getNode()) ||
       !IsProfitableToFold(N, P, P) ||

llvm/lib/Target/X86/X86ISelLowering.h

private:
     SDValue LowerBUILD_VECTOR(SDValue Op, SelectionDAG &DAG) const;
     SDValue LowerBUILD_VECTORvXi1(SDValue Op, SelectionDAG &DAG) const;
     SDValue LowerVSELECT(SDValue Op, SelectionDAG &DAG) const;
     SDValue LowerEXTRACT_VECTOR_ELT(SDValue Op, SelectionDAG &DAG) const;
     SDValue ExtractBitFromMaskVector(SDValue Op, SelectionDAG &DAG) const;
     SDValue InsertBitToMaskVector(SDValue Op, SelectionDAG &DAG) const;
     SDValue LowerINSERT_VECTOR_ELT(SDValue Op, SelectionDAG &DAG) const;
 
-    unsigned getGlobalWrapperKind() const;
+    unsigned getGlobalWrapperKind(const GlobalValue *GV = nullptr) const;
     SDValue LowerConstantPool(SDValue Op, SelectionDAG &DAG) const;
     SDValue LowerBlockAddress(SDValue Op, SelectionDAG &DAG) const;
     SDValue LowerGlobalAddress(const GlobalValue *GV, const SDLoc &dl,
                                int64_t Offset, SelectionDAG &DAG) const;
     SDValue LowerGlobalAddress(SDValue Op, SelectionDAG &DAG) const;
     SDValue LowerGlobalTLSAddress(SDValue Op, SelectionDAG &DAG) const;
     SDValue LowerExternalSymbol(SDValue Op, SelectionDAG &DAG) const;
 

llvm/lib/Target/X86/X86ISelLowering.cpp

static SDValue LowerINSERT_SUBVECTOR(SDValue Op, const X86Subtarget &Subtarget,
 
   if (SubVecVT.is256BitVector())
     return insert256BitVector(Vec, SubVec, IdxVal, DAG, dl);
 
   llvm_unreachable("Unimplemented!");
 }
 
 // Returns the appropriate wrapper opcode for a global reference.
-unsigned X86TargetLowering::getGlobalWrapperKind() const {
+unsigned X86TargetLowering::getGlobalWrapperKind(const GlobalValue *GV) 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))
     return X86ISD::WrapperRIP;
 
   return X86ISD::Wrapper;
 }
 
if (OpFlags == X86II::MO_NO_FLAG &&
       X86::isOffsetSuitableForCodeModel(Offset, M)) {
     // A direct static reference to a global.
     Result = DAG.getTargetGlobalAddress(GV, dl, PtrVT, Offset);
     Offset = 0;
   } else {
     Result = DAG.getTargetGlobalAddress(GV, dl, PtrVT, 0, OpFlags);
   }
 
-  Result = DAG.getNode(getGlobalWrapperKind(), dl, PtrVT, Result);
+  Result = DAG.getNode(getGlobalWrapperKind(GV), dl, PtrVT, Result);
 
   // With PIC, the address is actually $g + Offset.
   if (isGlobalRelativeToPICBase(OpFlags)) {
     Result = DAG.getNode(ISD::ADD, dl, PtrVT,
                          DAG.getNode(X86ISD::GlobalBaseReg, dl, PtrVT), Result);
   }
 
   // For globals that require a load from a stub to get the address, emit the

llvm/lib/Target/X86/X86InstrInfo.td

 // an issue with RA where we don't pull the constants into their users
 // when we rematerialize them. I'll follow-up on enabling O2 after we fix that
 // issue.
 // TODO3 : This is currently limited to single basic blocks (DAG creation
 // pulls block immediates to the top and merges them if necessary).
 // Eventually, it would be nice to allow ConstantHoisting to merge constants
 // globally for potentially added savings.
 //
-def imm8_su : PatLeaf<(i8 imm), [{
+def imm8_su : PatLeaf<(i8 relocImm), [{
     return !shouldAvoidImmediateInstFormsForSize(N);
 }]>;
-def imm16_su : PatLeaf<(i16 imm), [{
+def imm16_su : PatLeaf<(i16 relocImm), [{
     return !shouldAvoidImmediateInstFormsForSize(N);
 }]>;
 def imm32_su : PatLeaf<(i32 relocImm), [{
     return !shouldAvoidImmediateInstFormsForSize(N);
 }]>;
 def i64immSExt32_su : PatLeaf<(i64immSExt32), [{
     return !shouldAvoidImmediateInstFormsForSize(N);
 }]>;

llvm/lib/Target/X86/X86InstrShiftRotate.td

def ROR32rCL : I<0xD3, MRM1r, (outs GR32:$dst), (ins GR32:$src1),
                  [(set GR32:$dst, (rotr GR32:$src1, CL))], IIC_SR>, OpSize32;
 def ROR64rCL : RI<0xD3, MRM1r, (outs GR64:$dst), (ins GR64:$src1),
                   "ror{q}\t{%cl, $dst|$dst, cl}",
                   [(set GR64:$dst, (rotr GR64:$src1, CL))], IIC_SR>;
 }
 
 def ROR8ri   : Ii8<0xC0, MRM1r, (outs GR8 :$dst), (ins GR8 :$src1, u8imm:$src2),
                    "ror{b}\t{$src2, $dst|$dst, $src2}",
-                   [(set GR8:$dst, (rotr GR8:$src1, (i8 imm:$src2)))], IIC_SR>;
+                   [(set GR8:$dst, (rotr GR8:$src1, (i8 relocImm:$src2)))],
+                   IIC_SR>;
 def ROR16ri  : Ii8<0xC1, MRM1r, (outs GR16:$dst), (ins GR16:$src1, u8imm:$src2),
                    "ror{w}\t{$src2, $dst|$dst, $src2}",
-                   [(set GR16:$dst, (rotr GR16:$src1, (i8 imm:$src2)))],
+                   [(set GR16:$dst, (rotr GR16:$src1, (i8 relocImm:$src2)))],
                    IIC_SR>, OpSize16;
 def ROR32ri  : Ii8<0xC1, MRM1r, (outs GR32:$dst), (ins GR32:$src1, u8imm:$src2),
                    "ror{l}\t{$src2, $dst|$dst, $src2}",
-                   [(set GR32:$dst, (rotr GR32:$src1, (i8 imm:$src2)))],
+                   [(set GR32:$dst, (rotr GR32:$src1, (i8 relocImm:$src2)))],
                    IIC_SR>, OpSize32;
 def ROR64ri  : RIi8<0xC1, MRM1r, (outs GR64:$dst),
                     (ins GR64:$src1, u8imm:$src2),
                     "ror{q}\t{$src2, $dst|$dst, $src2}",
-                    [(set GR64:$dst, (rotr GR64:$src1, (i8 imm:$src2)))],
+                    [(set GR64:$dst, (rotr GR64:$src1, (i8 relocImm:$src2)))],
                     IIC_SR>;
 
 // Rotate by 1
 def ROR8r1   : I<0xD0, MRM1r, (outs GR8 :$dst), (ins GR8 :$src1),
                  "ror{b}\t$dst",
                  [(set GR8:$dst, (rotl GR8:$src1, (i8 7)))],
                  IIC_SR>;
 def ROR16r1  : I<0xD1, MRM1r, (outs GR16:$dst), (ins GR16:$src1),

llvm/lib/Target/X86/X86Subtarget.cpp

 }
 
 unsigned char X86Subtarget::classifyGlobalReference(const GlobalValue *GV,
                                                     const Module &M) const {
   // Large model never uses stubs.
   if (TM.getCodeModel() == CodeModel::Large)
     return X86II::MO_NO_FLAG;
 
+  // Absolute symbols can be referenced directly.
+  if (GV && GV->isAbsoluteSymbolRef())
+    return X86II::MO_NO_FLAG;
+
   if (TM.shouldAssumeDSOLocal(M, GV))
     return classifyLocalReference(GV);
 
   if (isTargetCOFF())
     return X86II::MO_DLLIMPORT;
 
   if (is64Bit())
     return X86II::MO_GOTPCREL;

llvm/test/CodeGen/X86/absolute-bit-mask.ll

+; RUN: llc < %s | FileCheck %s
+; RUN: llc -relocation-model=pic < %s | FileCheck %s
+
+target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128"
+target triple = "x86_64-unknown-linux-gnu"
+
+@bit_mask8 = external hidden global i8, !range !0
+@bit_mask32 = external hidden global i8, !range !1
+@bit_mask64 = external hidden global i8, !range !2
+
+declare void @f()
+
+define void @foo8(i8* %ptr) {
+  %load = load i8, i8* %ptr
+  ; CHECK: testb $bit_mask8, (%rdi)
+  %and = and i8 %load, ptrtoint (i8* @bit_mask8 to i8)
+  %icmp = icmp eq i8 %and, 0
+  br i1 %icmp, label %t, label %f
+
+t:
+  call void @f()
+  ret void
+
+f:
+  ret void
+}
+
+define void @foo32(i32* %ptr) {
+  %load = load i32, i32* %ptr
+  ; CHECK: testl $bit_mask32, (%rdi)
+  %and = and i32 %load, ptrtoint (i8* @bit_mask32 to i32)
+  %icmp = icmp eq i32 %and, 0
+  br i1 %icmp, label %t, label %f
+
+t:
+  call void @f()
+  ret void
+
+f:
+  ret void
+}
+
+define void @foo64(i64* %ptr) {
+  %load = load i64, i64* %ptr
+  ; CHECK: movabsq $bit_mask64, %rax
+  ; CHECK: testq (%rdi), %rax
+  %and = and i64 %load, ptrtoint (i8* @bit_mask64 to i64)
+  %icmp = icmp eq i64 %and, 0
+  br i1 %icmp, label %t, label %f
+
+t:
+  call void @f()
+  ret void
+
+f:
+  ret void
+}
+
+!0 = !{i64 0, i64 256}
+!1 = !{i64 0, i64 4294967296}
+!2 = !{i64 -1, i64 -1}

llvm/test/CodeGen/X86/absolute-bt.ll

+; RUN: llc < %s | FileCheck %s
+; RUN: llc -relocation-model=pic < %s | FileCheck %s
+
+target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128"
+target triple = "x86_64-unknown-linux-gnu"
+
+@bit_mask8 = external hidden global i8, !range !0
+@bit_mask32 = external hidden global i8, !range !1
+@bit_mask64 = external hidden global i8, !range !2
+
+declare void @f()
+
+define void @foo32(i32* %ptr) {
+  %load = load i32, i32* %ptr
+  %and = and i32 %load, 31
+  %shl = shl i32 1, %and
+  %and2 = and i32 %shl, ptrtoint (i8* @bit_mask32 to i32)
+  ; CHECK: movl $bit_mask32, %eax
+  ; CHECK: btl %ecx, %eax
+  %icmp = icmp eq i32 %and2, 0
+  br i1 %icmp, label %t, label %f
+
+t:
+  call void @f()
+  ret void
+
+f:
+  ret void
+}
+
+define void @foo64(i64* %ptr) {
+  %load = load i64, i64* %ptr
+  %and = and i64 %load, 63
+  %shl = shl i64 1, %and
+  %and2 = and i64 %shl, ptrtoint (i8* @bit_mask64 to i64)
+  ; CHECK: movabsq $bit_mask64, %rax
+  ; CHECK: btq %rcx, %rax
+  %icmp = icmp eq i64 %and2, 0
+  br i1 %icmp, label %t, label %f
+
+t:
+  call void @f()
+  ret void
+
+f:
+  ret void
+}
+
+!0 = !{i64 0, i64 256}
+!1 = !{i64 0, i64 4294967296}
+!2 = !{i64 -1, i64 -1}

llvm/test/CodeGen/X86/absolute-constant.ll

+; RUN: llc < %s | FileCheck %s
+; RUN: llc -relocation-model=pic < %s | FileCheck %s
+
+target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128"
+target triple = "x86_64-unknown-linux-gnu"
+
+@foo = external global i8, align 1, !range !0
+
+define void @bar(i8* %x) {
+entry:
+  %0 = load i8, i8* %x, align 1
+  %conv = sext i8 %0 to i32
+  ; CHECK: testb $foo, (%rdi)
+  %and = and i32 %conv, sext (i8 ptrtoint (i8* @foo to i8) to i32)
+  %tobool = icmp eq i32 %and, 0
+  br i1 %tobool, label %if.end, label %if.then
+
+if.then:                                          ; preds = %entry
+  tail call void (...) @xf()
+  br label %if.end
+
+if.end:                                           ; preds = %entry, %if.then
+  ret void
+}
+
+declare void @xf(...)
+
+!0 = !{i32 0, i32 256}

llvm/test/CodeGen/X86/absolute-rotate.ll

+; RUN: llc < %s | FileCheck %s
+; RUN: llc -relocation-model=pic < %s | FileCheck %s
+
+target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128"
+target triple = "x86_64-unknown-linux-gnu"
+
+@align = external hidden global i8, !range !0
+
+declare void @f()
+
+define void @foo(i64 %val) {
+  %shr = lshr i64 %val, zext (i8 ptrtoint (i8* @align to i8) to i64)
+  %shl = shl i64 %val, zext (i8 sub (i8 64, i8 ptrtoint (i8* @align to i8)) to i64)
+  ; CHECK: rorq $align, %rdi
+  %ror = or i64 %shr, %shl
+  %cmp = icmp ult i64 %ror, 109
+  br i1 %cmp, label %t, label %f
+
+t:
+  call void @f()
+  ret void
+
+f:
+  ret void
+}
+
+!0 = !{i64 0, i64 256}

llvm/test/Transforms/FunctionAttrs/nonnull-global.ll

+; RUN: opt -S -functionattrs %s | FileCheck %s
+
+@a = external global i8, !range !0
+
+; CHECK-NOT: define nonnull
+define i8* @foo() {
+  ret i8* @a
+}
+
+!0 = !{i64 0, i64 256}