[ThinLTO] only emit used or referenced CFI records to index

[inglorion]

Summary

We emit CFI_FUNCTION_DEFS and CFI_FUNCTION_DECLS to
distributed ThinLTO indices to implement indirect function call
checking. This change causes us to only emit entries for functions
that are either defined or used by the module we're writing the index
for (instead of all functions in the combined index), which can make
the indices substantially smaller.

Fixes PR42378.

[inglorion]

Use ModuleToSummariesForIndex to find GUIDs defined or used by the module

[inglorion]

As an example of what this does, I build Chrome (crrev.com/c/1673234 + crrev.com/c/1654198)'s base_unittests with and without this patch and looked at the sizes of the files generated for ThinLTO (.thinlto.bc, imports files, and native .o files).

without patch:

build time: 4:00.55
size of generated files: 1.5G

with patch:

build time: 3:54.38
size of generated files: 754M

The generated base_unittests binary was the same size and passes tests with or without the patch.

[inglorion]

Added test and reworded commit message.

[inglorion]

clang-format

[vitalybuka]

llvm/lib/Bitcode/Writer/BitcodeWriter.cpp

3886–3887

why do you need this change?

[inglorion]

rebase and back out unnecessary change

[inglorion]

Thanks for the review!

llvm/lib/Bitcode/Writer/BitcodeWriter.cpp

3886–3887

Thanks for spotting that! I don't need this anymore, but forgot to undo it. Undone now.

llvm/lib/Bitcode/Writer/BitcodeWriter.cpp

void IndexBitcodeWriter::writeCombinedGlobalValueSummary() {
   if (Index.hasSyntheticEntryCounts())
     Flags |= 0x4;
   if (Index.enableSplitLTOUnit())
     Flags |= 0x8;
   if (Index.partiallySplitLTOUnits())
     Flags |= 0x10;
   Stream.EmitRecord(bitc::FS_FLAGS, ArrayRef<uint64_t>{Flags});
 
-  for (const auto &GVI : valueIds()) {
+  const std::map<GlobalValue::GUID, unsigned> &ValueIds = valueIds();
+  for (const auto &GVI : ValueIds) {
     Stream.EmitRecord(bitc::FS_VALUE_GUID,
                       ArrayRef<uint64_t>{GVI.second, GVI.first});
   }
 
   // Abbrev for FS_COMBINED.
   auto Abbv = std::make_shared<BitCodeAbbrev>();
   Abbv->Add(BitCodeAbbrevOp(bitc::FS_COMBINED));
   Abbv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 8));   // valueid
void IndexBitcodeWriter::writeCombinedGlobalValueSummary() {
   auto MaybeEmitOriginalName = [&](GlobalValueSummary &S) {
     if (!GlobalValue::isLocalLinkage(S.linkage()))
       return;
     NameVals.push_back(S.getOriginalName());
     Stream.EmitRecord(bitc::FS_COMBINED_ORIGINAL_NAME, NameVals);
     NameVals.clear();
   };
 
+  std::set<GlobalValue::GUID> DefOrUseGUIDs;
   forEachSummary([&](GVInfo I, bool IsAliasee) {
     GlobalValueSummary *S = I.second;
     assert(S);
+    DefOrUseGUIDs.insert(I.first);
+    for (const ValueInfo &VI : S->refs())
+      DefOrUseGUIDs.insert(VI.getGUID());
 
     auto ValueId = getValueId(I.first);
     assert(ValueId);
     SummaryToValueIdMap[S] = *ValueId;
 
     // If this is invoked for an aliasee, we want to record the above
     // mapping, but then not emit a summary entry (if the aliasee is
     // to be imported, we will invoke this separately with IsAliasee=false).
for (auto *AS : Aliases) {
     MaybeEmitOriginalName(*AS);
 
     if (auto *FS = dyn_cast<FunctionSummary>(&AS->getAliasee()))
       getReferencedTypeIds(FS, ReferencedTypeIds);
   }
 
   if (!Index.cfiFunctionDefs().empty()) {
     for (auto &S : Index.cfiFunctionDefs()) {
+      if (DefOrUseGUIDs.count(GlobalValue::getGUID(GlobalValue::dropLLVMManglingEscape(S)))) {
         NameVals.push_back(StrtabBuilder.add(S));
         NameVals.push_back(S.size());
       }
+    }
+    if (!NameVals.empty()) {
       Stream.EmitRecord(bitc::FS_CFI_FUNCTION_DEFS, NameVals);
       NameVals.clear();
     }
+  }
 
   if (!Index.cfiFunctionDecls().empty()) {
     for (auto &S : Index.cfiFunctionDecls()) {
+      if (DefOrUseGUIDs.count(GlobalValue::getGUID(GlobalValue::dropLLVMManglingEscape(S)))) {
         NameVals.push_back(StrtabBuilder.add(S));
         NameVals.push_back(S.size());
       }
+    }
+    if (!NameVals.empty()) {
       Stream.EmitRecord(bitc::FS_CFI_FUNCTION_DECLS, NameVals);
       NameVals.clear();
     }
+  }
 
   // Walk the GUIDs that were referenced, and write the
   // corresponding type id records.
   for (auto &T : ReferencedTypeIds) {
     auto TidIter = Index.typeIds().equal_range(T);
     for (auto It = TidIter.first; It != TidIter.second; ++It) {
       writeTypeIdSummaryRecord(NameVals, StrtabBuilder, It->second.first,
                                It->second.second);

llvm/test/ThinLTO/X86/Inputs/cfi-icall-only-bazqux.ll

+target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128"
+target triple = "x86_64-unknown-linux-gnu"
+
+declare !type !0 i8 @bar(i8*)
+declare i1 @llvm.type.test(i8* %ptr, metadata %type) nounwind readnone
+
+define i8 @baz(i8* %p) !type !0 {
+  %x = call i1 @llvm.type.test(i8* %p, metadata !"t1")
+  %1 = select i1 %x, i8 0, i8 3
+  ret i8 %1
+}
+
+define i8 @qux(i8* %p) !type !0 {
+  %x = call i1 @llvm.type.test(i8* %p, metadata !"t1")
+  ret i8 4
+}
+
+define i8 @g(i1 %i, i8* %p) {
+  %1 = select i1 %i, i8(i8*)* @bar, i8(i8*)* @qux
+  %2 = call i8 %1(i8* %p)
+  ret i8 %2
+}
+
+!0 = !{i64 0, !"t1"}

llvm/test/ThinLTO/X86/cfi-icall-only-defuse.ll

+; Verifies that only functions defined or used by each module make it into the
+; CFI functions sets in that module's distributed index.
+; RUN: opt -thinlto-bc -thinlto-split-lto-unit %s -o %t1.bc
+; RUN: opt -thinlto-bc -thinlto-split-lto-unit %S/Inputs/cfi-icall-only-bazqux.ll -o %t2.bc
+; RUN: llvm-lto2 run  -thinlto-distributed-indexes %t1.bc %t2.bc -o %t.out \
+; RUN:   -r %t1.bc,bar,plx \
+; RUN:   -r %t1.bc,baz,x   \
+; RUN:   -r %t1.bc,f,plx   \
+; RUN:   -r %t1.bc,foo,plx \
+; RUN:   -r %t2.bc,bar,x   \
+; RUN:   -r %t2.bc,baz,plx \
+; RUN:   -r %t2.bc,g,plx   \
+; RUN:   -r %t2.bc,qux,plx
+; RUN: llvm-bcanalyzer -dump %t1.bc.thinlto.bc | FileCheck %s --check-prefix=FOOBAZ
+; RUN: llvm-bcanalyzer -dump %t2.bc.thinlto.bc | FileCheck %s --check-prefix=BARQUX
+
+target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128"
+target triple = "x86_64-unknown-linux-gnu"
+
+declare !type !0 i8 @baz(i8*)
+declare i1 @llvm.type.test(i8* %ptr, metadata %type) nounwind readnone
+
+define i8 @foo(i8* %p) !type !0 {
+  %x = call i1 @llvm.type.test(i8* %p, metadata !"t1")
+  %1 = select i1 %x, i8 0, i8 1
+  ret i8 %1
+}
+
+define i8 @bar(i8* %p) !type !0 {
+  %x = call i1 @llvm.type.test(i8* %p, metadata !"t1")
+  ret i8 2
+}
+
+define i8 @f(i1 %i, i8* %p) {
+  %1 = select i1 %i, i8(i8*)* @foo, i8(i8*)* @baz
+  %2 = call i8 %1(i8* %p)
+  ret i8 %2
+}
+
+!0 = !{i64 0, !"t1"}
+
+; FOOBAZ:   <GLOBALVAL_SUMMARY_BLOCK
+; FOOBAZ:     <CFI_FUNCTION_DEFS op0=0 op1=3 op2=3 op3=3 op4=6 op5=3/>
+; FOOBAZ:     <TYPE_ID op0=9 op1=2 op2=4 op3=7 op4=0 op5=0 op6=0 op7=0/>
+; FOOBAZ:   </GLOBALVAL_SUMMARY_BLOCK>
+; FOOBAZ:      <STRTAB_BLOCK
+; FOOBAZ-NEXT:   <BLOB abbrevid=4/> blob data = 'barbazfoot1'
+; FOOBAZ-NEXT: </STRTAB_BLOCK>
+
+; BARQUX:   <GLOBALVAL_SUMMARY_BLOCK
+; BARQUX:     <CFI_FUNCTION_DEFS op0=0 op1=3 op2=3 op3=3 op4=6 op5=3/>
+; BARQUX:     <TYPE_ID op0=9 op1=2 op2=4 op3=7 op4=0 op5=0 op6=0 op7=0/>
+; BARQUX:   </GLOBALVAL_SUMMARY_BLOCK>
+; BARQUX:      <STRTAB_BLOCK
+; BARQUX-NEXT:   <BLOB abbrevid=4/> blob data = 'barbazquxt1'
+; BARQUX-NEXT: </STRTAB_BLOCK>