[ThinLTO] Add some stats for read only variable internalization

[tejohnson]

Summary

Follow up to D49362 ([ThinLTO] Internalize read only globals). Add a
statistic on the number of read only variables (only counting live
variables since dead variables will be dropped anyway).

[evgeny777]

Thanks!

lib/IR/ModuleSummaryIndex.cpp

 //===-- ModuleSummaryIndex.cpp - Module Summary Index ---------------------===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 //
 // This file implements the module index and summary classes for the
 // IR library.
 //
 //===----------------------------------------------------------------------===//
 
 #include "llvm/IR/ModuleSummaryIndex.h"
 #include "llvm/ADT/SCCIterator.h"
+#include "llvm/ADT/Statistic.h"
 #include "llvm/ADT/StringMap.h"
 #include "llvm/Support/Path.h"
 #include "llvm/Support/raw_ostream.h"
 using namespace llvm;
 
+#define DEBUG_TYPE "module-summary-index"
+
+STATISTIC(ReadOnlyLiveGVars,
+          "Number of live global variables marked read only");
+
 FunctionSummary FunctionSummary::ExternalNode =
     FunctionSummary::makeDummyFunctionSummary({});
 bool ValueInfo::isDSOLocal() const {
   // Need to check all summaries are local in case of hash collisions.
   return getSummaryList().size() &&
          llvm::all_of(getSummaryList(),
                       [](const std::unique_ptr<GlobalValueSummary> &Summary) {
                         return Summary->isDSOLocal();
for (auto &S : P.second.SummaryList) {
       // in the @llvm.*used).
       if (auto *GVS = dyn_cast<GlobalVarSummary>(S->getBaseObject()))
         // Here we intentionally pass S.get() not GVS, because S could be
         // an alias.
         if (!canImportGlobalVar(S.get()) || GUIDPreservedSymbols.count(P.first))
           GVS->setReadOnly(false);
       propagateConstantsToRefs(S.get());
     }
+#if LLVM_ENABLE_STATS
+  for (auto &P : *this)
+    if (P.second.SummaryList.size())
+      if (auto *GVS = dyn_cast<GlobalVarSummary>(
+              P.second.SummaryList[0]->getBaseObject()))
+        if (isGlobalValueLive(GVS) && GVS->isReadOnly())
+          ReadOnlyLiveGVars++;
+#endif
 }
 
 // TODO: write a graphviz dumper for SCCs (see ModuleSummaryIndex::exportToDot)
 // then delete this function and update its tests
 LLVM_DUMP_METHOD
 void ModuleSummaryIndex::dumpSCCs(raw_ostream &O) {
   for (scc_iterator<ModuleSummaryIndex *> I =
            scc_begin<ModuleSummaryIndex *>(this);

test/ThinLTO/X86/index-const-prop.ll

 ; Check constant propagation in thinlto combined summary. This allows us to do 2 things:
 ;  1. Internalize global definition which is not used externally if all accesses to it are read-only
 ;  2. Make a local copy of internal definition if all accesses to it are readonly. This allows constant
 ;     folding it during optimziation phase.
 
+; -stats requires asserts
+; REQUIRES: asserts
+
 ; RUN: opt -module-summary %s -o %t1.bc
 ; RUN: opt -module-summary %p/Inputs/index-const-prop.ll -o %t2.bc
 ; RUN: llvm-lto -thinlto-action=thinlink -o %t3.index.bc %t1.bc %t2.bc
-; RUN: llvm-lto -thinlto-action=import -exported-symbol=main  %t1.bc -thinlto-index=%t3.index.bc -o %t1.imported.bc
+; RUN: llvm-lto -thinlto-action=import -exported-symbol=main  %t1.bc -thinlto-index=%t3.index.bc -o %t1.imported.bc -stats 2>&1 | FileCheck %s --check-prefix=STATS
 ; RUN: llvm-dis %t1.imported.bc -o - | FileCheck %s --check-prefix=IMPORT
 ; RUN: llvm-lto -thinlto-action=optimize %t1.imported.bc -o - | llvm-dis - -o - | FileCheck %s --check-prefix=OPTIMIZE
 
+; STATS: 2 module-summary-index - Number of live global variables marked read only
+
 ; Check that we don't internalize gBar when it is exported
 ; RUN: llvm-lto -thinlto-action=import -exported-symbol main -exported-symbol gBar  %t1.bc -thinlto-index=%t3.index.bc -o %t1.imported2.bc
 ; RUN: llvm-dis %t1.imported2.bc -o - | FileCheck %s --check-prefix=IMPORT2
 
 ; IMPORT: @gFoo.llvm.0 = internal unnamed_addr global i32 1, align 4, !dbg !0
 ; IMPORT-NEXT: @gBar = internal local_unnamed_addr global i32 2, align 4, !dbg !5
 ; IMPORT: !DICompileUnit({{.*}}, globals: !{{[0-9]+}})
 
 ; OPTIMIZE:        define i32 @main
 ; OPTIMIZE-NEXT:     ret i32 3
 
 ; IMPORT2: @gBar = available_externally local_unnamed_addr global i32 2, align 4, !dbg !5
 
 target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128"
 target triple = "x86_64-pc-linux-gnu"
 
 @gBar = external global i32
 
+; Should not be counted in the stats of live read only variables since it is
+; dead and will be dropped anyway.
+@gDead = internal unnamed_addr global i32 1, align 4
+
 define i32 @main() local_unnamed_addr {
   %call = tail call i32 bitcast (i32 (...)* @foo to i32 ()*)()
   %call1 = tail call i32 bitcast (i32 (...)* @bar to i32 ()*)()
   %add = add nsw i32 %call1, %call
   ret i32 %add
 }
 
 declare i32 @foo(...) local_unnamed_addr
 
 declare i32 @bar(...) local_unnamed_addr