Use a new Function::FunctionVisibility flag to cache the result

of isFullyInternal().

Author: JonPsson1

llvm/include/llvm/IR/Function.h

@@ -115,6 +115,13 @@ class LLVM_ABI Function : public GlobalObject, public ilist_node<Function> {
   /// \ref BasicBlock.
   bool IsNewDbgInfoFormat;
 
+  /// If this function is known to be fully internal or not, this is set. A
+  /// function with local linkage can still be passed as a pointer to an
+  /// external routine, in which case it would be classified as External
+  /// here.
+  enum class FunctionVisibility { Unknown, FullyInternal, External };
+  mutable FunctionVisibility FunVisibility;
+
   /// hasLazyArguments/CheckLazyArguments - The argument list of a function is
   /// built on demand, so that the list isn't allocated until the first client
   /// needs it.  The hasLazyArguments predicate returns true if the arg list

llvm/lib/IR/Function.cpp

@@ -492,7 +492,8 @@ Function::Function(FunctionType *Ty, LinkageTypes Linkage, unsigned AddrSpace,
                    const Twine &name, Module *ParentModule)
     : GlobalObject(Ty, Value::FunctionVal, AllocMarker, Linkage, name,
                    computeAddrSpace(AddrSpace, ParentModule)),
-      NumArgs(Ty->getNumParams()), IsNewDbgInfoFormat(UseNewDbgInfoFormat) {
+      NumArgs(Ty->getNumParams()), IsNewDbgInfoFormat(UseNewDbgInfoFormat),
+      FunVisibility(FunctionVisibility::Unknown) {
   assert(FunctionType::isValidReturnType(getReturnType()) &&
          "invalid return type");
   setGlobalObjectSubClassData(0);

llvm/lib/Target/SystemZ/SystemZISelLowering.cpp

@@ -10200,10 +10200,7 @@ SDValue SystemZTargetLowering::lowerVECREDUCE_ADD(SDValue Op,
       DAG.getConstant(OpVT.getVectorNumElements() - 1, DL, MVT::i32));
 }
 
-// Only consider a function fully internal as long as it has local linkage
-// and is not used in any other way than acting as the called function at
-// call sites.
-bool SystemZTargetLowering::isFullyInternal(const Function *Fn) const {
+bool SystemZTargetLowering::isFullyInternal_impl(const Function *Fn) const {
   if (!Fn->hasLocalLinkage())
     return false;
   for (const User *U : Fn->users()) {
@@ -10216,6 +10213,17 @@ bool SystemZTargetLowering::isFullyInternal(const Function *Fn) const {
   return true;
 }
 
+// Only consider a function fully internal as long as it has local linkage
+// and is not used in any other way than acting as the called function at
+// call sites.
+bool SystemZTargetLowering::isFullyInternal(const Function *Fn) const {
+  if (Fn->FunVisibility == Function::FunctionVisibility::Unknown)
+    Fn->FunVisibility = isFullyInternal_impl(Fn)
+                            ? Function::FunctionVisibility::FullyInternal
+                            : Function::FunctionVisibility::External;
+  return Fn->FunVisibility == Function::FunctionVisibility::FullyInternal;
+}
+
 static void printFunctionArgExts(const Function *F, raw_fd_ostream &OS) {
   FunctionType *FT = F->getFunctionType();
   const AttributeList &Attrs = F->getAttributes();

llvm/lib/Target/SystemZ/SystemZISelLowering.h

@@ -815,6 +815,7 @@ class SystemZTargetLowering : public TargetLowering {
   getTargetMMOFlags(const Instruction &I) const override;
   const TargetRegisterClass *getRepRegClassFor(MVT VT) const override;
 
+  bool isFullyInternal_impl(const Function *Fn) const;
   bool isFullyInternal(const Function *Fn) const;
   void verifyNarrowIntegerArgs_Call(const SmallVectorImpl<ISD::OutputArg> &Outs,
                                     const Function *F, SDValue Callee) const;