[AssumptionCache] Track GlobalValues as affected values.

[tylanphear]

Summary

Fixes a corner case of the analysis: previously GlobalValues could be
affected by assumptions, but were not tracked within AffectedValues.
This patch allows assumptions which affect a given GlobalValue to be
looked up via assumptionsFor().

A small update to llvm/test/Analysis/ScalarEvolution/ranges.ll was
necessary due to knowledge about a global value now being propagated
from AssumptionCache -> ValueTracking -> ScalarEvolution.

[jdoerfert]

LG

[tylanphear]

I do not have commit access, would someone who does please land this for me? Thanks!

[tylanphear]

Friendly ping -- @jdoerfert perhaps you could land this, since you approved? I would greatly appreciate it. Thanks!

[tylanphear]

Actually, it seems I should submit this as PR on GitHub, now that the process has been changed. Closing this revision in favor of https://github.com/llvm/llvm-project/pull/65425.

llvm/lib/Analysis/AssumptionCache.cpp

 //===- AssumptionCache.cpp - Cache finding @llvm.assume calls -------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 //

 static void
 findAffectedValues(CallBase *CI, TargetTransformInfo *TTI,
                    SmallVectorImpl<AssumptionCache::ResultElem> &Affected) {
   // Note: This code must be kept in-sync with the code in
   // computeKnownBitsFromAssume in ValueTracking.
 
   auto AddAffected = [&Affected](Value *V, unsigned Idx =
                                                AssumptionCache::ExprResultIdx) {
-    if (isa<Argument>(V)) {
+    if (isa<Argument>(V) || isa<GlobalValue>(V)) {
       Affected.push_back({V, Idx});
     } else if (auto *I = dyn_cast<Instruction>(V)) {
       Affected.push_back({I, Idx});
 
       // Peek through unary operators to find the source of the condition.
       Value *Op;
       if (match(I, m_BitCast(m_Value(Op))) ||
           match(I, m_PtrToInt(m_Value(Op))) || match(I, m_Not(m_Value(Op)))) {

llvm/test/Analysis/AssumptionCache/basic.ll

entry:
   call void @llvm.assume(i1 %cond1)
   %cond2 = icmp slt i32 %a, 0
   call void @llvm.assume(i1 %cond2)
   %cond3 = icmp sgt i32 %a, 0
   call void @llvm.assume(i1 %cond3)
 
   ret void
 }
+
+@G = external global i32
+define void @test2() {
+; CHECK-LABEL: Cached assumptions for function: test2
+; CHECK-NEXT: icmp ne ptr @G, null
+
+entry:
+  %cond1 = icmp ne ptr @G, null
+  call void @llvm.assume(i1 %cond1)
+  ret void
+}

llvm/test/Analysis/ScalarEvolution/ranges.ll

 
 ; Highlight the fact that non-argument non-instructions are
 ; also possible.
 @G = external global i8
 define i64 @ashr_global() {
 ; CHECK-LABEL: 'ashr_global'
 ; CHECK-NEXT:  Classifying expressions for: @ashr_global
 ; CHECK-NEXT:    %ashr = ashr i64 ptrtoint (ptr @G to i64), 63
-; CHECK-NEXT:    --> %ashr U: [-1,1) S: [-1,1)
+; CHECK-NEXT:    --> %ashr U: [0,1) S: [0,1)
 ; CHECK-NEXT:  Determining loop execution counts for: @ashr_global
 ;
   %ashr = ashr i64 ptrtoint (ptr @G to i64), 63
   %pos = icmp sge ptr @G, null
   call void @llvm.assume(i1 %pos)
   ret i64 %ashr
 }