Skip CFI for dead functions.

[pcc]

lib/Transforms/IPO/WholeProgramDevirt.cpp

1327 ↗

(On Diff #100797)

Is there test coverage for the not-live case here?

test/Transforms/LowerTypeTests/Inputs/use-typeid1-dead.yaml

6

Just guid("typeid1") I think?

[eugenis]

Remove WholeProgramDevirt part for now as I don't have a good test case for it.

[pcc]

LGTM

[eugenis]

Submitted in r304578.

include/llvm/IR/ModuleSummaryIndexYAML.h

 template <> struct MappingTraits<TypeIdSummary> {
   static void mapping(IO &io, TypeIdSummary& summary) {
     io.mapOptional("TTRes", summary.TTRes);
     io.mapOptional("WPDRes", summary.WPDRes);
   }
 };
 
 struct FunctionSummaryYaml {
+  unsigned Linkage;
+  bool NotEligibleToImport, Live;
   std::vector<uint64_t> TypeTests;
   std::vector<FunctionSummary::VFuncId> TypeTestAssumeVCalls,
       TypeCheckedLoadVCalls;
   std::vector<FunctionSummary::ConstVCall> TypeTestAssumeConstVCalls,
       TypeCheckedLoadConstVCalls;
 };
 
 } // End yaml namespace

 LLVM_YAML_IS_SEQUENCE_VECTOR(FunctionSummary::VFuncId)
 LLVM_YAML_IS_SEQUENCE_VECTOR(FunctionSummary::ConstVCall)
 
 namespace llvm {
 namespace yaml {
 
 template <> struct MappingTraits<FunctionSummaryYaml> {
   static void mapping(IO &io, FunctionSummaryYaml& summary) {
+    io.mapOptional("Linkage", summary.Linkage);
+    io.mapOptional("NotEligibleToImport", summary.NotEligibleToImport);
+    io.mapOptional("Live", summary.Live);
     io.mapOptional("TypeTests", summary.TypeTests);
     io.mapOptional("TypeTestAssumeVCalls", summary.TypeTestAssumeVCalls);
     io.mapOptional("TypeCheckedLoadVCalls", summary.TypeCheckedLoadVCalls);
     io.mapOptional("TypeTestAssumeConstVCalls",
                    summary.TypeTestAssumeConstVCalls);
     io.mapOptional("TypeCheckedLoadConstVCalls",
                    summary.TypeCheckedLoadConstVCalls);
   }
static void inputOne(IO &io, StringRef Key, GlobalValueSummaryMapTy &V) {
     io.mapRequired(Key.str().c_str(), FSums);
     uint64_t KeyInt;
     if (Key.getAsInteger(0, KeyInt)) {
       io.setError("key not an integer");
       return;
     }
     auto &Elem = V[KeyInt];
     for (auto &FSum : FSums) {
-      GlobalValueSummary::GVFlags GVFlags(GlobalValue::ExternalLinkage, false,
-                                          false);
       Elem.SummaryList.push_back(llvm::make_unique<FunctionSummary>(
-          GVFlags, 0, ArrayRef<ValueInfo>{},
-          ArrayRef<FunctionSummary::EdgeTy>{}, std::move(FSum.TypeTests),
-          std::move(FSum.TypeTestAssumeVCalls),
+          GlobalValueSummary::GVFlags(
+              static_cast<GlobalValue::LinkageTypes>(FSum.Linkage),
+              FSum.NotEligibleToImport, FSum.Live),
+          0, ArrayRef<ValueInfo>{}, ArrayRef<FunctionSummary::EdgeTy>{},
+          std::move(FSum.TypeTests), std::move(FSum.TypeTestAssumeVCalls),
           std::move(FSum.TypeCheckedLoadVCalls),
           std::move(FSum.TypeTestAssumeConstVCalls),
           std::move(FSum.TypeCheckedLoadConstVCalls)));
     }
   }
   static void output(IO &io, GlobalValueSummaryMapTy &V) {
     for (auto &P : V) {
       std::vector<FunctionSummaryYaml> FSums;
       for (auto &Sum : P.second.SummaryList) {
         if (auto *FSum = dyn_cast<FunctionSummary>(Sum.get()))
           FSums.push_back(FunctionSummaryYaml{
-              FSum->type_tests(), FSum->type_test_assume_vcalls(),
-              FSum->type_checked_load_vcalls(),
+              FSum->flags().Linkage,
+              static_cast<bool>(FSum->flags().NotEligibleToImport),
+              static_cast<bool>(FSum->flags().Live), FSum->type_tests(),
+              FSum->type_test_assume_vcalls(), FSum->type_checked_load_vcalls(),
               FSum->type_test_assume_const_vcalls(),
               FSum->type_checked_load_const_vcalls()});
       }
       if (!FSums.empty())
         io.mapRequired(llvm::utostr(P.first).c_str(), FSums);
     }
   }
 };
 
 template <> struct MappingTraits<ModuleSummaryIndex> {
   static void mapping(IO &io, ModuleSummaryIndex& index) {
     io.mapOptional("GlobalValueMap", index.GlobalValueMap);
     io.mapOptional("TypeIdMap", index.TypeIdMap);
+    io.mapOptional("WithGlobalValueDeadStripping",
+                   index.WithGlobalValueDeadStripping);
   }
 };
 
 } // End yaml namespace
 } // End llvm namespace
 
 #endif

lib/Transforms/IPO/LowerTypeTests.cpp

for (auto &P : TypeIdInfo) {
       if (auto *TypeId = dyn_cast<MDString>(P.first))
         MetadataByGUID[GlobalValue::getGUID(TypeId->getString())].push_back(
             TypeId);
     }
 
     for (auto &P : *ExportSummary) {
       for (auto &S : P.second.SummaryList) {
         auto *FS = dyn_cast<FunctionSummary>(S.get());
-        if (!FS)
+        if (!FS || !ExportSummary->isGlobalValueLive(FS))
           continue;
-        // FIXME: Only add live functions.
         for (GlobalValue::GUID G : FS->type_tests())
           for (Metadata *MD : MetadataByGUID[G])
             AddTypeIdUse(MD).IsExported = true;
       }
     }
   }
 
   if (GlobalClasses.empty())

test/Transforms/LowerTypeTests/Inputs/import-unsat.yaml

 ---
 GlobalValueMap:
   42:
-    - TypeTests: [123]
+    - Live: true
+      TypeTests: [123]
 TypeIdMap:
   typeid1:
     TTRes:
       Kind: Unsat
       SizeM1BitWidth: 0
 ...

test/Transforms/LowerTypeTests/Inputs/use-typeid1-dead.yaml

+---
+GlobalValueMap:
+  42:
+    - Live: false
+      TypeTests: [14276520915468743435] # guid("typeid1")
+WithGlobalValueDeadStripping: true
+...

test/Transforms/LowerTypeTests/Inputs/use-typeid1-typeid2.yaml

 ---
 GlobalValueMap:
   42:
-    - TypeTests: [14276520915468743435, 15427464259790519041] # guid("typeid1"), guid("typeid2")
+    - Live: true
+      TypeTests: [14276520915468743435, 15427464259790519041] # guid("typeid1"), guid("typeid2")
 ...

test/Transforms/LowerTypeTests/export-dead.ll

+; The only use of "typeid1" is in a dead function. Export nothing.
+
+; RUN: opt -S -lowertypetests -lowertypetests-summary-action=export -lowertypetests-read-summary=%S/Inputs/use-typeid1-dead.yaml -lowertypetests-write-summary=%t < %s | FileCheck %s
+; RUN: FileCheck --check-prefix=SUMMARY %s < %t
+
+@foo = constant i32 42, !type !0
+
+!0 = !{i32 0, !"typeid1"}
+
+; CHECK-NOT: @__typeid_typeid1_global_addr =
+
+; SUMMARY:      TypeIdMap:
+; SUMMARY-NEXT: WithGlobalValueDeadStripping: true
+; SUMMARY-NEXT: ...

test/Transforms/LowerTypeTests/export-nothing.ll

 ; RUN: opt -lowertypetests -lowertypetests-summary-action=export -lowertypetests-write-summary=%t -o /dev/null %s
 ; RUN: FileCheck %s < %t
 
 ; CHECK: ---
 ; CHECK-NEXT: GlobalValueMap:
 ; CHECK-NEXT: TypeIdMap:
+; CHECK-NEXT: WithGlobalValueDeadStripping: false
 ; CHECK-NEXT: ...

test/Transforms/LowerTypeTests/import-unsat.ll

 ; Test that we correctly import an unsat resolution for type identifier "typeid1".
 ; RUN: opt -S -lowertypetests -lowertypetests-summary-action=import -lowertypetests-read-summary=%S/Inputs/import-unsat.yaml -lowertypetests-write-summary=%t < %s | FileCheck %s
 ; RUN: FileCheck --check-prefix=SUMMARY %s < %t
 
 ; SUMMARY:      GlobalValueMap:
 ; SUMMARY-NEXT:   42:
-; SUMMARY-NEXT:     - TypeTests: [ 123 ]
+; SUMMARY-NEXT:    - Linkage:             0
+; SUMMARY-NEXT:      NotEligibleToImport: false
+; SUMMARY-NEXT:      Live:                true
+; SUMMARY-NEXT:      TypeTests: [ 123 ]
 ; SUMMARY-NEXT: TypeIdMap:
 ; SUMMARY-NEXT:   typeid1:
 ; SUMMARY-NEXT:     TTRes:
 ; SUMMARY-NEXT:       Kind:            Unsat
 ; SUMMARY-NEXT:       SizeM1BitWidth:  0
 
 target datalayout = "e-p:32:32"
 
 declare i1 @llvm.type.test(i8* %ptr, metadata %bitset) nounwind readnone
 
 define i1 @foo(i8* %p) {
   %x = call i1 @llvm.type.test(i8* %p, metadata !"typeid1")
   ; CHECK: ret i1 false
   ret i1 %x
 }

test/Transforms/WholeProgramDevirt/Inputs/export.yaml

 ---
 GlobalValueMap:
   42:
-    - TypeTestAssumeVCalls:
+    - Live: true
+      TypeTestAssumeVCalls:
         - GUID: 14276520915468743435  # typeid1
           Offset: 0
       TypeCheckedLoadVCalls:
         - GUID: 15427464259790519041  # typeid2
           Offset: 0
       TypeTestAssumeConstVCalls:
         - VFunc:
             GUID: 3515965990081467659  # typeid3
             Offset: 0
           Args: [12, 24]
       TypeCheckedLoadConstVCalls:
         - VFunc:
             GUID: 17525413373118030901  # typeid4
             Offset: 0
           Args: [24, 12]
 ...

test/Transforms/WholeProgramDevirt/Inputs/import-indir.yaml

 ---
 GlobalValueMap:
   42:
-    - TypeTestAssumeVCalls:
+    - Live: true
+      TypeTestAssumeVCalls:
         - GUID: 123
           Offset: 0
         - GUID: 456
           Offset: 4
       TypeCheckedLoadVCalls:
         - GUID: 789
           Offset: 8
         - GUID: 1234

test/Transforms/WholeProgramDevirt/export-nothing.ll

 ; RUN: opt -wholeprogramdevirt -wholeprogramdevirt-summary-action=export -wholeprogramdevirt-write-summary=%t -o /dev/null %s
 ; RUN: FileCheck %s < %t
 
 ; CHECK: ---
 ; CHECK-NEXT: GlobalValueMap:
 ; CHECK-NEXT: TypeIdMap:
+; CHECK-NEXT: WithGlobalValueDeadStripping: false
 ; CHECK-NEXT: ...

test/Transforms/WholeProgramDevirt/export-single-impl.ll

 ; SUMMARY-NEXT:     TTRes:
 ; SUMMARY-NEXT:       Kind:            Unsat
 ; SUMMARY-NEXT:       SizeM1BitWidth:  0
 ; SUMMARY-NEXT:     WPDRes:
 ; SUMMARY-NEXT:       0:
 ; SUMMARY-NEXT:         Kind:            SingleImpl
 ; SUMMARY-NEXT:         SingleImplName:  'vf4$merged'
 ; SUMMARY-NEXT:         ResByArg:
+; SUMMARY-NEXT: WithGlobalValueDeadStripping: false
 ; SUMMARY-NEXT: ...
 
 ; CHECK: @vt1 = constant void (i8*)* @vf1
 @vt1 = constant void (i8*)* @vf1, !type !0
 
 ; CHECK: @vt2 = constant void (i8*)* @vf2
 @vt2 = constant void (i8*)* @vf2, !type !1
 

test/Transforms/WholeProgramDevirt/export-uniform-ret-val.ll

 ; RUN: opt -wholeprogramdevirt -wholeprogramdevirt-summary-action=export -wholeprogramdevirt-read-summary=%S/Inputs/export.yaml -wholeprogramdevirt-write-summary=%t -S -o - %s | FileCheck %s
 ; RUN: FileCheck --check-prefix=SUMMARY %s < %t
 
-; SUMMARY:     - TypeTests:
-; SUMMARY-NEXT:  TypeTestAssumeVCalls:
+; SUMMARY-NOT: TypeTests:
 
 ; SUMMARY:      TypeIdMap:
 ; SUMMARY-NEXT:   typeid4:
 ; SUMMARY-NEXT:     TTRes:
 ; SUMMARY-NEXT:       Kind:            Unsat
 ; SUMMARY-NEXT:       SizeM1BitWidth:  0
 ; SUMMARY-NEXT:     WPDRes:
 ; SUMMARY-NEXT:       0:

test/Transforms/WholeProgramDevirt/export-unique-ret-val.ll

 ; RUN: opt -wholeprogramdevirt -wholeprogramdevirt-summary-action=export -wholeprogramdevirt-read-summary=%S/Inputs/export.yaml -wholeprogramdevirt-write-summary=%t -S -o - %s | FileCheck %s
 ; RUN: FileCheck --check-prefix=SUMMARY %s < %t
 
-; SUMMARY:     - TypeTests:
-; SUMMARY-NEXT:  TypeTestAssumeVCalls:
+; SUMMARY-NOT:  TypeTests:
 
 ; SUMMARY:      TypeIdMap:
 ; SUMMARY-NEXT:   typeid3:
 ; SUMMARY-NEXT:     TTRes:
 ; SUMMARY-NEXT:       Kind:            Unsat
 ; SUMMARY-NEXT:       SizeM1BitWidth:  0
 ; SUMMARY-NEXT:     WPDRes:
 ; SUMMARY-NEXT:       0:

test/Transforms/WholeProgramDevirt/export-unsuccessful-checked.ll

 ; RUN: opt -wholeprogramdevirt -wholeprogramdevirt-summary-action=export -wholeprogramdevirt-read-summary=%S/Inputs/export.yaml -wholeprogramdevirt-write-summary=%t -o /dev/null %s
 ; RUN: FileCheck %s < %t
 
-; CHECK:     - TypeTests: [ 15427464259790519041, 17525413373118030901 ]
+; CHECK:       TypeTests: [ 15427464259790519041, 17525413373118030901 ]
 ; CHECK-NEXT:  TypeTestAssumeVCalls:
 
 @vt1a = constant void (i8*)* @vf1a, !type !0
 @vt1b = constant void (i8*)* @vf1b, !type !0
 @vt2a = constant void (i8*)* @vf2a, !type !1
 @vt2b = constant void (i8*)* @vf2b, !type !1
 @vt3a = constant void (i8*)* @vf3a, !type !2
 @vt3b = constant void (i8*)* @vf3b, !type !2

test/Transforms/WholeProgramDevirt/import-indir.ll

 ; Test that we correctly import an indir resolution for type identifier "typeid1".
 ; RUN: opt -S -wholeprogramdevirt -wholeprogramdevirt-summary-action=import -wholeprogramdevirt-read-summary=%S/Inputs/import-indir.yaml -wholeprogramdevirt-write-summary=%t < %s | FileCheck %s
 ; RUN: FileCheck --check-prefix=SUMMARY %s < %t
 
 ; SUMMARY:     GlobalValueMap:
 ; SUMMARY-NEXT:  42:
-; SUMMARY-NEXT:    - TypeTests:
+; SUMMARY-NEXT:    - Linkage:             0
+; SUMMARY-NEXT:      NotEligibleToImport: false
+; SUMMARY-NEXT:      Live:                true
 ; SUMMARY-NEXT:      TypeTestAssumeVCalls:
 ; SUMMARY-NEXT:        - GUID:            123
 ; SUMMARY-NEXT:          Offset:          0
 ; SUMMARY-NEXT:        - GUID:            456
 ; SUMMARY-NEXT:          Offset:          4
 ; SUMMARY-NEXT:      TypeCheckedLoadVCalls:
 ; SUMMARY-NEXT:        - GUID:            789
 ; SUMMARY-NEXT:          Offset:          8