File Manager

003 File Manager

Current Path: /usr/src/contrib/llvm-project/llvm/lib/Transforms/Utils

usr / src / contrib / llvm-project / llvm / lib / Transforms / Utils /

📁 ..
📄 AMDGPUEmitPrintf.cpp(8.57 KB)
📄 ASanStackFrameLayout.cpp(5.75 KB)
📄 AddDiscriminators.cpp(10.78 KB)
📄 AssumeBundleBuilder.cpp(21.46 KB)
📄 BasicBlockUtils.cpp(51.81 KB)
📄 BreakCriticalEdges.cpp(19.03 KB)
📄 BuildLibCalls.cpp(43.9 KB)
📄 BypassSlowDivision.cpp(17.95 KB)
📄 CallGraphUpdater.cpp(5.76 KB)
📄 CallPromotionUtils.cpp(22.18 KB)
📄 CanonicalizeAliases.cpp(3.18 KB)
📄 CanonicalizeFreezeInLoops.cpp(7.93 KB)
📄 CloneFunction.cpp(34.49 KB)
📄 CloneModule.cpp(7.93 KB)
📄 CodeExtractor.cpp(65.69 KB)
📄 CodeMoverUtils.cpp(15.82 KB)
📄 CtorUtils.cpp(5.1 KB)
📄 Debugify.cpp(17.78 KB)
📄 DemoteRegToStack.cpp(6.1 KB)
📄 EntryExitInstrumenter.cpp(5.83 KB)
📄 EscapeEnumerator.cpp(2.96 KB)
📄 Evaluator.cpp(27.98 KB)
📄 FixIrreducible.cpp(12.68 KB)
📄 FlattenCFG.cpp(16.99 KB)
📄 FunctionComparator.cpp(34.36 KB)
📄 FunctionImportUtils.cpp(13.8 KB)
📄 GlobalStatus.cpp(7.23 KB)
📄 GuardUtils.cpp(4.76 KB)
📄 ImportedFunctionsInliningStatistics.cpp(7.67 KB)
📄 InjectTLIMappings.cpp(6.62 KB)
📄 InlineFunction.cpp(103.28 KB)
📄 InstructionNamer.cpp(1.98 KB)
📄 IntegerDivision.cpp(26.17 KB)
📄 LCSSA.cpp(18.72 KB)
📄 LibCallsShrinkWrap.cpp(18.68 KB)
📄 Local.cpp(114.96 KB)
📄 LoopRotationUtils.cpp(29.47 KB)
📄 LoopSimplify.cpp(36.13 KB)
📄 LoopUnroll.cpp(38.07 KB)
📄 LoopUnrollAndJam.cpp(37.71 KB)
📄 LoopUnrollPeel.cpp(31.88 KB)
📄 LoopUnrollRuntime.cpp(40.17 KB)
📄 LoopUtils.cpp(65.03 KB)
📄 LoopVersioning.cpp(12.42 KB)
📄 LowerInvoke.cpp(3.3 KB)
📄 LowerMemIntrinsics.cpp(20.41 KB)
📄 LowerSwitch.cpp(23.46 KB)
📄 Mem2Reg.cpp(3.71 KB)
📄 MetaRenamer.cpp(5.29 KB)
📄 MisExpect.cpp(6.97 KB)
📄 ModuleUtils.cpp(10.99 KB)
📄 NameAnonGlobals.cpp(3.33 KB)
📄 PredicateInfo.cpp(36.79 KB)
📄 PromoteMemoryToRegister.cpp(37.26 KB)
📄 SSAUpdater.cpp(16.72 KB)
📄 SSAUpdaterBulk.cpp(7.46 KB)
📄 SanitizerStats.cpp(4.08 KB)
📄 ScalarEvolutionExpander.cpp(101.25 KB)
📄 SimplifyCFG.cpp(238.13 KB)
📄 SimplifyIndVar.cpp(34.53 KB)
📄 SimplifyLibCalls.cpp(122.25 KB)
📄 SizeOpts.cpp(5.08 KB)
📄 SplitModule.cpp(9.67 KB)
📄 StripGCRelocates.cpp(2.86 KB)
📄 StripNonLineTableDebugInfo.cpp(1.4 KB)
📄 SymbolRewriter.cpp(18.82 KB)
📄 UnifyFunctionExitNodes.cpp(4.42 KB)
📄 UnifyLoopExits.cpp(8.16 KB)
📄 UniqueInternalLinkageNames.cpp(2.91 KB)
📄 Utils.cpp(2.53 KB)
📄 VNCoercion.cpp(25.89 KB)
📄 ValueMapper.cpp(38.06 KB)

Editing: CallGraphUpdater.cpp

//===- CallGraphUpdater.cpp - A (lazy) call graph update helper -----------===//
//
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
//
//===----------------------------------------------------------------------===//
/// \file
///
/// This file provides interfaces used to manipulate a call graph, regardless
/// if it is a "old style" CallGraph or an "new style" LazyCallGraph.
///
//===----------------------------------------------------------------------===//

#include "llvm/Transforms/Utils/CallGraphUpdater.h"
#include "llvm/ADT/STLExtras.h"
#include "llvm/Transforms/Utils/ModuleUtils.h"

using namespace llvm;

bool CallGraphUpdater::finalize() {
  if (!DeadFunctionsInComdats.empty()) {
    filterDeadComdatFunctions(*DeadFunctionsInComdats.front()->getParent(),
                              DeadFunctionsInComdats);
    DeadFunctions.append(DeadFunctionsInComdats.begin(),
                         DeadFunctionsInComdats.end());
  }

if (CG) {
    // First remove all references, e.g., outgoing via called functions. This is
    // necessary as we can delete functions that have circular references.
    for (Function *DeadFn : DeadFunctions) {
      DeadFn->removeDeadConstantUsers();
      CallGraphNode *DeadCGN = (*CG)[DeadFn];
      DeadCGN->removeAllCalledFunctions();
      CG->getExternalCallingNode()->removeAnyCallEdgeTo(DeadCGN);
      DeadFn->replaceAllUsesWith(UndefValue::get(DeadFn->getType()));
    }

// Then remove the node and function from the module.
    for (Function *DeadFn : DeadFunctions) {
      CallGraphNode *DeadCGN = CG->getOrInsertFunction(DeadFn);
      assert(DeadCGN->getNumReferences() == 0 &&
             "References should have been handled by now");
      delete CG->removeFunctionFromModule(DeadCGN);
    }
  } else {
    // This is the code path for the new lazy call graph and for the case were
    // no call graph was provided.
    for (Function *DeadFn : DeadFunctions) {
      DeadFn->removeDeadConstantUsers();
      DeadFn->replaceAllUsesWith(UndefValue::get(DeadFn->getType()));

if (LCG && !ReplacedFunctions.count(DeadFn)) {
        // Taken mostly from the inliner:
        LazyCallGraph::Node &N = LCG->get(*DeadFn);
        auto *DeadSCC = LCG->lookupSCC(N);
        assert(DeadSCC && DeadSCC->size() == 1 &&
               &DeadSCC->begin()->getFunction() == DeadFn);
        auto &DeadRC = DeadSCC->getOuterRefSCC();

FunctionAnalysisManager &FAM =
            AM->getResult<FunctionAnalysisManagerCGSCCProxy>(*DeadSCC, *LCG)
                .getManager();

FAM.clear(*DeadFn, DeadFn->getName());
        AM->clear(*DeadSCC, DeadSCC->getName());
        LCG->removeDeadFunction(*DeadFn);

// Mark the relevant parts of the call graph as invalid so we don't
        // visit them.
        UR->InvalidatedSCCs.insert(DeadSCC);
        UR->InvalidatedRefSCCs.insert(&DeadRC);
      }

// The function is now really dead and de-attached from everything.
      DeadFn->eraseFromParent();
    }
  }

bool Changed = !DeadFunctions.empty();
  DeadFunctionsInComdats.clear();
  DeadFunctions.clear();
  return Changed;
}

void CallGraphUpdater::reanalyzeFunction(Function &Fn) {
  if (CG) {
    CallGraphNode *OldCGN = CG->getOrInsertFunction(&Fn);
    OldCGN->removeAllCalledFunctions();
    CG->populateCallGraphNode(OldCGN);
  } else if (LCG) {
    LazyCallGraph::Node &N = LCG->get(Fn);
    LazyCallGraph::SCC *C = LCG->lookupSCC(N);
    updateCGAndAnalysisManagerForCGSCCPass(*LCG, *C, N, *AM, *UR, *FAM);
  }
}

void CallGraphUpdater::registerOutlinedFunction(Function &NewFn) {
  if (CG)
    CG->addToCallGraph(&NewFn);
  else if (LCG)
    LCG->addNewFunctionIntoSCC(NewFn, *SCC);
}

void CallGraphUpdater::removeFunction(Function &DeadFn) {
  DeadFn.deleteBody();
  DeadFn.setLinkage(GlobalValue::ExternalLinkage);
  if (DeadFn.hasComdat())
    DeadFunctionsInComdats.push_back(&DeadFn);
  else
    DeadFunctions.push_back(&DeadFn);

// For the old call graph we remove the function from the SCC right away.
  if (CG && !ReplacedFunctions.count(&DeadFn)) {
    CallGraphNode *DeadCGN = (*CG)[&DeadFn];
    DeadCGN->removeAllCalledFunctions();
    CGSCC->DeleteNode(DeadCGN);
  }
}

void CallGraphUpdater::replaceFunctionWith(Function &OldFn, Function &NewFn) {
  OldFn.removeDeadConstantUsers();
  ReplacedFunctions.insert(&OldFn);
  if (CG) {
    // Update the call graph for the newly promoted function.
    CallGraphNode *OldCGN = (*CG)[&OldFn];
    CallGraphNode *NewCGN = CG->getOrInsertFunction(&NewFn);
    NewCGN->stealCalledFunctionsFrom(OldCGN);
    CG->ReplaceExternalCallEdge(OldCGN, NewCGN);

// And update the SCC we're iterating as well.
    CGSCC->ReplaceNode(OldCGN, NewCGN);
  } else if (LCG) {
    // Directly substitute the functions in the call graph.
    LazyCallGraph::Node &OldLCGN = LCG->get(OldFn);
    SCC->getOuterRefSCC().replaceNodeFunction(OldLCGN, NewFn);
  }
  removeFunction(OldFn);
}

bool CallGraphUpdater::replaceCallSite(CallBase &OldCS, CallBase &NewCS) {
  // This is only necessary in the (old) CG.
  if (!CG)
    return true;

Function *Caller = OldCS.getCaller();
  CallGraphNode *NewCalleeNode =
      CG->getOrInsertFunction(NewCS.getCalledFunction());
  CallGraphNode *CallerNode = (*CG)[Caller];
  if (llvm::none_of(*CallerNode, [&OldCS](const CallGraphNode::CallRecord &CR) {
        return CR.first && *CR.first == &OldCS;
      }))
    return false;
  CallerNode->replaceCallEdge(OldCS, NewCS, NewCalleeNode);
  return true;
}

void CallGraphUpdater::removeCallSite(CallBase &CS) {
  // This is only necessary in the (old) CG.
  if (!CG)
    return;

Function *Caller = CS.getCaller();
  CallGraphNode *CallerNode = (*CG)[Caller];
  CallerNode->removeCallEdgeFor(CS);
}

003 File Manager

Editing: CallGraphUpdater.cpp

Upload File

Create Folder