Delete mayBeOverridden

[• rafael]

Summary

It is the same as isInterposable which seems to be the preferred name.

[rnk]

Given your coming changes, yeah, this naming makes sense. We should ask the people who cared about the nomenclature when Sanjoy added mayBeDeRefined, though.

[sanjoy]

I had some vague concerns about having mayBeOverridden be "linker oriented" and isInterposable be "optimization oriented". But I don't have a concrete reason why this cleanup is not a good idea, and we can always refactor later, so LGTM.

[Eugene.Zelenko]

Committed in r269150.

include/llvm/IR/GlobalValue.h

bool mayBeDerefined() const {
     case WeakAnyLinkage:
     case LinkOnceAnyLinkage:
     case CommonLinkage:
     case ExternalWeakLinkage:
     case ExternalLinkage:
     case AppendingLinkage:
     case InternalLinkage:
     case PrivateLinkage:
-      return mayBeOverridden();
+      return isInterposable();
     }
 
     llvm_unreachable("Fully covered switch above!");
   }
 
-  /// Whether the definition of this global may be replaced by something
-  /// non-equivalent at link time. For example, if a function has weak linkage
-  /// then the code defining it may be replaced by different code.
-  bool mayBeOverridden() const {
-    return isMayBeOverriddenLinkage(getLinkage());
-  }
-
 protected:
   /// \brief The intrinsic ID for this subclass (which must be a Function).
   ///
   /// This member is defined by this class, but not used for anything.
   /// Subclasses can use it to store their intrinsic ID, if they have one.
   ///
   /// This is stored here to save space in Function on 64-bit hosts.
   Intrinsic::ID IntID;
public:
   }
   static bool isCommonLinkage(LinkageTypes Linkage) {
     return Linkage == CommonLinkage;
   }
 
   /// Whether the definition of this global may be replaced by something
   /// non-equivalent at link time. For example, if a function has weak linkage
   /// then the code defining it may be replaced by different code.
-  static bool isMayBeOverriddenLinkage(LinkageTypes Linkage) {
+  static bool isInterposableLinkage(LinkageTypes Linkage) {
     switch (Linkage) {
     case WeakAnyLinkage:
     case LinkOnceAnyLinkage:
     case CommonLinkage:
     case ExternalWeakLinkage:
       return true;
 
     case AvailableExternallyLinkage:
public:
   /// in its compilation unit.
   static bool isDiscardableIfUnused(LinkageTypes Linkage) {
     return isLinkOnceLinkage(Linkage) || isLocalLinkage(Linkage) ||
            isAvailableExternallyLinkage(Linkage);
   }
 
   /// Whether the definition of this global may be replaced at link time.  NB:
   /// Using this method outside of the code generators is almost always a
-  /// mistake: when working at the IR level use mayBeOverridden instead as it
+  /// mistake: when working at the IR level use isInterposable instead as it
   /// knows about ODR semantics.
   static bool isWeakForLinker(LinkageTypes Linkage)  {
     return Linkage == WeakAnyLinkage || Linkage == WeakODRLinkage ||
            Linkage == LinkOnceAnyLinkage || Linkage == LinkOnceODRLinkage ||
            Linkage == CommonLinkage || Linkage == ExternalWeakLinkage;
   }
 
   /// Return true if the currently visible definition of this global (if any) is
bool hasExactDefinition() const {
     // is in low level code generation.
     return !isDeclaration() && isDefinitionExact();
   }
 
   /// Return true if this global's definition can be substituted with an
   /// *arbitrary* definition at link time.  We cannot do any IPO or inlinining
   /// across interposable call edges, since the callee can be replaced with
   /// something arbitrary at link time.
-  bool isInterposable() const { return mayBeOverridden(); }
+  bool isInterposable() const { return isInterposableLinkage(getLinkage()); }
 
   bool hasExternalLinkage() const { return isExternalLinkage(getLinkage()); }
   bool hasAvailableExternallyLinkage() const {
     return isAvailableExternallyLinkage(getLinkage());
   }
   bool hasLinkOnceLinkage() const { return isLinkOnceLinkage(getLinkage()); }
   bool hasLinkOnceODRLinkage() const {
     return isLinkOnceODRLinkage(getLinkage());

lib/Transforms/IPO/FunctionImport.cpp

 static const GlobalValueSummary *
 selectCallee(const ModuleSummaryIndex &Index,
              const GlobalValueSummaryList &CalleeSummaryList,
              unsigned Threshold) {
   auto It = llvm::find_if(
       CalleeSummaryList,
       [&](const std::unique_ptr<GlobalValueSummary> &SummaryPtr) {
         auto *GVSummary = SummaryPtr.get();
-        if (GlobalValue::isMayBeOverriddenLinkage(GVSummary->linkage()))
+        if (GlobalValue::isInterposableLinkage(GVSummary->linkage()))
           // There is no point in importing these, we can't inline them
           return false;
         if (auto *AS = dyn_cast<AliasSummary>(GVSummary)) {
           GVSummary = &AS->getAliasee();
           // Alias can't point to "available_externally". However when we import
           // linkOnceODR the linkage does not change. So we import the alias
           // and aliasee only in this case.
           // FIXME: we should import alias as available_externally *function*,