Const fold vtable load from global variable

[gberry]

Summary

Take advantage of the TBAA "vtable access" annotation on loads of a
global variable's vtable.  This annotation marks loads as being loads of
a C++ object's vtable pointer.  Since we know that a vtable pointer
cannot be changed to a different value after object construction, if we
see a global object with an initializer that has a non-null vtable
pointer, we can replace vtable loads from that object with the global
initializer's vtable value.

[gberry]

Touching to get email send to llvm-commits

[reames]

General comment: Having a special case in TBAA for a constant after initialization value seems like the wrong factoring here. Supporting a more general extensions of !invariant.load would seem to be more generally useful.

Having said that, it doesn't look like you're adding the mechanism, just extending it. As such, my comment isn't directly relevant to the patch at hand.

[gberry]

Ping?

FWIW, this change improves spec2006/astar by 6% on AArch64 a57

[rnk]

@majnemer and I agree that this is incorrect. It ignores how the vtable changes over time during object construction.

[gberry]

Reid,

Thanks for your feedback. Just to be clear, your objection is that there may be subsequent writes to @gS's vtable pointer during construction such that the value folded into @gS's initializer (i.e. the first vtable value written) is different from the value that would be loaded at the call site?

[rnk]

In D11043#210866, @gberry wrote:

Reid,

Thanks for your feedback. Just to be clear, your objection is that there may be subsequent writes to @gS's vtable pointer during construction such that the value folded into @gS's initializer (i.e. the first vtable value written) is different from the value that would be loaded at the call site?

Exactly. Right now it seems like you're looking for "does the relevant field of this global have a non-zero value". For now, this coincidentally does the trick, but there's no real guarantee that it will always work.

include/llvm/Analysis/ConstantFolding.h

 /// ConstantFoldInsertValueInstruction - Attempt to constant fold an insertvalue
 /// instruction with the specified operands and indices.  The constant result is
 /// returned if successful; if not, null is returned.
 Constant *ConstantFoldInsertValueInstruction(Constant *Agg, Constant *Val,
                                              ArrayRef<unsigned> Idxs);
 
 /// ConstantFoldLoadFromConstPtr - Return the value that a load from C would
 /// produce if it is constant and determinable.  If this is not determinable,
-/// return null.
-Constant *ConstantFoldLoadFromConstPtr(Constant *C, const DataLayout &DL);
+/// return null.  If AssumeGVConst is true, assume that the base GlobalVariable
+/// in C (if there is one) is constant even if the IR indicates otherwise.
+Constant *ConstantFoldLoadFromConstPtr(Constant *C, const DataLayout &DL,
+                                       bool AssumeGVConst = false);
 
 /// ConstantFoldLoadThroughGEPConstantExpr - Given a constant and a
 /// getelementptr constantexpr, return the constant value being addressed by the
 /// constant expression, or null if something is funny and we can't decide.
 Constant *ConstantFoldLoadThroughGEPConstantExpr(Constant *C, ConstantExpr *CE);
 
 /// ConstantFoldLoadThroughGEPIndices - Given a constant and getelementptr
 /// indices (with an *implied* zero pointer index that is not in the list),

lib/Analysis/ConstantFolding.cpp

 #include "llvm/IR/Constants.h"
 #include "llvm/IR/DataLayout.h"
 #include "llvm/IR/DerivedTypes.h"
 #include "llvm/IR/Function.h"
 #include "llvm/IR/GetElementPtrTypeIterator.h"
 #include "llvm/IR/GlobalVariable.h"
 #include "llvm/IR/Instructions.h"
 #include "llvm/IR/Intrinsics.h"
+#include "llvm/IR/LLVMContext.h"
 #include "llvm/IR/Operator.h"
 #include "llvm/Support/ErrorHandling.h"
 #include "llvm/Support/MathExtras.h"
 #include <cerrno>
 #include <cmath>
 
 #ifdef HAVE_FENV_H
 #include <fenv.h>
for (unsigned i = 1; i != BytesLoaded; ++i) {
       ResultVal <<= 8;
       ResultVal |= RawBytes[i];
     }
   }
 
   return ConstantInt::get(IntType->getContext(), ResultVal);
 }
 
+/// If AssumeGVConst is true, assume that the base GlobalVariable in C (if there
+/// is one) is constant even if the IR indicates otherwise.
 static Constant *ConstantFoldLoadThroughBitcast(ConstantExpr *CE,
-                                                const DataLayout &DL) {
+                                                const DataLayout &DL,
+                                                bool AssumeGVConst) {
   auto *DestPtrTy = dyn_cast<PointerType>(CE->getType());
   if (!DestPtrTy)
     return nullptr;
   Type *DestTy = DestPtrTy->getElementType();
 
-  Constant *C = ConstantFoldLoadFromConstPtr(CE->getOperand(0), DL);
+  Constant *C = ConstantFoldLoadFromConstPtr(CE->getOperand(0), DL, AssumeGVConst);
   if (!C)
     return nullptr;
 
   do {
     Type *SrcTy = C->getType();
 
     // If the type sizes are the same and a cast is legal, just directly
     // cast the constant.
do {
     // castable to implement the "load" semantic model.
     C = C->getAggregateElement(0u);
   } while (C);
 
   return nullptr;
 }
 
 /// Return the value that a load from C would produce if it is constant and
-/// determinable. If this is not determinable, return null.
+/// determinable. If this is not determinable, return null. If AssumeGVConst is
+/// true, assume that the base GlobalVariable in C (if there is one) is constant
+/// even if the IR indicates otherwise.
 Constant *llvm::ConstantFoldLoadFromConstPtr(Constant *C,
-                                             const DataLayout &DL) {
+                                             const DataLayout &DL,
+                                             bool AssumeGVConst) {
   // First, try the easy cases:
   if (GlobalVariable *GV = dyn_cast<GlobalVariable>(C))
-    if (GV->isConstant() && GV->hasDefinitiveInitializer())
+    if ((AssumeGVConst || GV->isConstant()) && GV->hasDefinitiveInitializer())
       return GV->getInitializer();
 
   // If the loaded value isn't a constant expr, we can't handle it.
   ConstantExpr *CE = dyn_cast<ConstantExpr>(C);
   if (!CE)
     return nullptr;
 
   if (CE->getOpcode() == Instruction::GetElementPtr) {
     if (GlobalVariable *GV = dyn_cast<GlobalVariable>(CE->getOperand(0))) {
-      if (GV->isConstant() && GV->hasDefinitiveInitializer()) {
+      if ((AssumeGVConst || GV->isConstant()) && GV->hasDefinitiveInitializer()) {
         if (Constant *V =
              ConstantFoldLoadThroughGEPConstantExpr(GV->getInitializer(), CE))
           return V;
       }
     }
   }
 
   if (CE->getOpcode() == Instruction::BitCast)
-    if (Constant *LoadedC = ConstantFoldLoadThroughBitcast(CE, DL))
+    if (Constant *LoadedC = ConstantFoldLoadThroughBitcast(CE, DL, AssumeGVConst))
       return LoadedC;
 
   // Instead of loading constant c string, use corresponding integer value
   // directly if string length is small enough.
   StringRef Str;
   if (getConstantStringInfo(CE, Str) && !Str.empty()) {
     unsigned StrLen = Str.size();
     Type *Ty = cast<PointerType>(CE->getType())->getElementType();
if (GV->isConstant() && GV->hasDefinitiveInitializer()) {
         return UndefValue::get(ResTy);
     }
   }
 
   // Try hard to fold loads from bitcasted strange and non-type-safe things.
   return FoldReinterpretLoadFromConstPtr(CE, DL);
 }
 
+static bool isVtableLoad(const Instruction *I) {
+  if (MDNode *Tag = I->getMetadata(LLVMContext::MD_tbaa))
+    return Tag->isTBAAVtableAccess();
+  return false;
+}
+
 static Constant *ConstantFoldLoadInst(const LoadInst *LI,
                                       const DataLayout &DL) {
   if (LI->isVolatile()) return nullptr;
 
-  if (Constant *C = dyn_cast<Constant>(LI->getOperand(0)))
-    return ConstantFoldLoadFromConstPtr(C, DL);
+  if (Constant *C = dyn_cast<Constant>(LI->getOperand(0))) {
+    bool IsVTableLoad = isVtableLoad(LI);
+    Constant *FoldedC = ConstantFoldLoadFromConstPtr(C, DL, IsVTableLoad);
+    if (IsVTableLoad && FoldedC) {
+      if (!FoldedC->isZeroValue())
+        return FoldedC;
+      return nullptr;
+    }
+    return FoldedC;
+  }
 
   return nullptr;
 }
 
 /// One of Op0/Op1 is a constant expression.
 /// Attempt to symbolically evaluate the result of a binary operator merging
 /// these together.  If target data info is available, it is provided as DL,
 /// otherwise DL is null.

test/Transforms/InstCombine/constant-fold-global-vtable-load.ll

+; RUN: opt -S -instcombine %s -o - | FileCheck %s
+target datalayout = "e-m:e-i64:64-i128:128-n8:16:32:64-S128"
+
+%class.S = type { i32 (...)** }
+@gS = global %class.S { i32 (...)** bitcast (i8** getelementptr inbounds ([3 x i8*], [3 x i8*]* @_ZTV1S, i64 0, i64 2) to i32 (...)**) }
+@_ZTV1S = unnamed_addr constant [3 x i8*] [i8* null, i8* null, i8* bitcast (i32 (%class.S*, i32)* @memberfunc to i8*)]
+
+declare  i32 @memberfunc(%class.S* nocapture readnone %this, i32 %x)
+
+define i32 @foo() {
+; CHECK-LABEL: foo
+entry:
+  %0 = bitcast %class.S* @gS to i32 (%class.S*, i32)***
+  %vtable = load i32 (%class.S*, i32)**, i32 (%class.S*, i32)*** %0, !tbaa !1
+  %1 = load i32 (%class.S*, i32)*, i32 (%class.S*, i32)** %vtable
+; CHECK: call i32 @memberfunc
+  %call = tail call i32 %1(%class.S* @gS, i32 0)
+  ret i32 %call
+}
+
+!1 = !{!2, !2, i64 0}
+!2 = !{!"vtable pointer", !3, i64 0}
+!3 = !{!"Simple C/C++ TBAA"}