File Manager

003 File Manager

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

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

📁 ..
📄 ADCE.cpp(24.71 KB)
📄 AlignmentFromAssumptions.cpp(15.9 KB)
📄 BDCE.cpp(7.42 KB)
📄 CallSiteSplitting.cpp(21.43 KB)
📄 ConstantHoisting.cpp(38.95 KB)
📄 ConstantProp.cpp(4.13 KB)
📄 CorrelatedValuePropagation.cpp(32.36 KB)
📄 DCE.cpp(6.84 KB)
📄 DeadStoreElimination.cpp(91.51 KB)
📄 DivRemPairs.cpp(15.01 KB)
📄 EarlyCSE.cpp(57.05 KB)
📄 FlattenCFGPass.cpp(2.74 KB)
📄 Float2Int.cpp(18.19 KB)
📄 GVN.cpp(100.11 KB)
📄 GVNHoist.cpp(44.85 KB)
📄 GVNSink.cpp(29.97 KB)
📄 GuardWidening.cpp(32.36 KB)
📄 IVUsersPrinter.cpp(839 B)
📄 IndVarSimplify.cpp(113.49 KB)
📄 InductiveRangeCheckElimination.cpp(72.96 KB)
📄 InferAddressSpaces.cpp(44.22 KB)
📄 InstSimplifyPass.cpp(5.39 KB)
📄 JumpThreading.cpp(115.06 KB)
📄 LICM.cpp(92.71 KB)
📄 LoopAccessAnalysisPrinter.cpp(977 B)
📄 LoopDataPrefetch.cpp(14.54 KB)
📄 LoopDeletion.cpp(11.37 KB)
📄 LoopDistribute.cpp(40.25 KB)
📄 LoopFuse.cpp(68.6 KB)
📄 LoopIdiomRecognize.cpp(69.09 KB)
📄 LoopInstSimplify.cpp(9.38 KB)
📄 LoopInterchange.cpp(60.65 KB)
📄 LoopLoadElimination.cpp(26.71 KB)
📄 LoopPassManager.cpp(4.02 KB)
📄 LoopPredication.cpp(49.21 KB)
📄 LoopRerollPass.cpp(58.54 KB)
📄 LoopRotation.cpp(4.79 KB)
📄 LoopSimplifyCFG.cpp(28.59 KB)
📄 LoopSink.cpp(14.93 KB)
📄 LoopStrengthReduce.cpp(216.88 KB)
📄 LoopUnrollAndJamPass.cpp(21.07 KB)
📄 LoopUnrollPass.cpp(60.73 KB)
📄 LoopUnswitch.cpp(64.17 KB)
📄 LoopVersioningLICM.cpp(23.65 KB)
📄 LowerAtomic.cpp(5.12 KB)
📄 LowerConstantIntrinsics.cpp(5.8 KB)
📄 LowerExpectIntrinsic.cpp(15 KB)
📄 LowerGuardIntrinsic.cpp(2.82 KB)
📄 LowerMatrixIntrinsics.cpp(73.36 KB)
📄 LowerWidenableCondition.cpp(2.75 KB)
📄 MakeGuardsExplicit.cpp(3.83 KB)
📄 MemCpyOptimizer.cpp(52.16 KB)
📄 MergeICmps.cpp(35.61 KB)
📄 MergedLoadStoreMotion.cpp(15.18 KB)
📄 NaryReassociate.cpp(19.86 KB)
📄 NewGVN.cpp(170.95 KB)
📄 PartiallyInlineLibCalls.cpp(6.22 KB)
📄 PlaceSafepoints.cpp(27.5 KB)
📄 Reassociate.cpp(95.61 KB)
📄 Reg2Mem.cpp(4.34 KB)
📄 RewriteStatepointsForGC.cpp(116.35 KB)
📄 SCCP.cpp(76.12 KB)
📄 SROA.cpp(183.83 KB)
📄 Scalar.cpp(10.08 KB)
📄 Scalarizer.cpp(32.93 KB)
📄 SeparateConstOffsetFromGEP.cpp(52.99 KB)
📄 SimpleLoopUnswitch.cpp(124.57 KB)
📄 SimplifyCFGPass.cpp(12.31 KB)
📄 Sink.cpp(10.81 KB)
📄 SpeculateAroundPHIs.cpp(35.69 KB)
📄 SpeculativeExecution.cpp(11.54 KB)
📄 StraightLineStrengthReduce.cpp(28.92 KB)
📄 StructurizeCFG.cpp(32.49 KB)
📄 TailRecursionElimination.cpp(34.9 KB)
📄 WarnMissedTransforms.cpp(6.14 KB)

Editing: PartiallyInlineLibCalls.cpp

//===--- PartiallyInlineLibCalls.cpp - Partially inline libcalls ----------===//
//
// 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
//
//===----------------------------------------------------------------------===//
//
// This pass tries to partially inline the fast path of well-known library
// functions, such as using square-root instructions for cases where sqrt()
// does not need to set errno.
//
//===----------------------------------------------------------------------===//

#include "llvm/Transforms/Scalar/PartiallyInlineLibCalls.h"
#include "llvm/Analysis/TargetLibraryInfo.h"
#include "llvm/Analysis/TargetTransformInfo.h"
#include "llvm/IR/IRBuilder.h"
#include "llvm/InitializePasses.h"
#include "llvm/Support/DebugCounter.h"
#include "llvm/Transforms/Scalar.h"
#include "llvm/Transforms/Utils/BasicBlockUtils.h"

using namespace llvm;

#define DEBUG_TYPE "partially-inline-libcalls"

DEBUG_COUNTER(PILCounter, "partially-inline-libcalls-transform",
              "Controls transformations in partially-inline-libcalls");

static bool optimizeSQRT(CallInst *Call, Function *CalledFunc,
                         BasicBlock &CurrBB, Function::iterator &BB,
                         const TargetTransformInfo *TTI) {
  // There is no need to change the IR, since backend will emit sqrt
  // instruction if the call has already been marked read-only.
  if (Call->onlyReadsMemory())
    return false;

if (!DebugCounter::shouldExecute(PILCounter))
    return false;

// Do the following transformation:
  //
  // (before)
  // dst = sqrt(src)
  //
  // (after)
  // v0 = sqrt_noreadmem(src) # native sqrt instruction.
  // [if (v0 is a NaN) || if (src < 0)]
  //   v1 = sqrt(src)         # library call.
  // dst = phi(v0, v1)
  //

// Move all instructions following Call to newly created block JoinBB.
  // Create phi and replace all uses.
  BasicBlock *JoinBB = llvm::SplitBlock(&CurrBB, Call->getNextNode());
  IRBuilder<> Builder(JoinBB, JoinBB->begin());
  Type *Ty = Call->getType();
  PHINode *Phi = Builder.CreatePHI(Ty, 2);
  Call->replaceAllUsesWith(Phi);

// Create basic block LibCallBB and insert a call to library function sqrt.
  BasicBlock *LibCallBB = BasicBlock::Create(CurrBB.getContext(), "call.sqrt",
                                             CurrBB.getParent(), JoinBB);
  Builder.SetInsertPoint(LibCallBB);
  Instruction *LibCall = Call->clone();
  Builder.Insert(LibCall);
  Builder.CreateBr(JoinBB);

// Add attribute "readnone" so that backend can use a native sqrt instruction
  // for this call. Insert a FP compare instruction and a conditional branch
  // at the end of CurrBB.
  Call->addAttribute(AttributeList::FunctionIndex, Attribute::ReadNone);
  CurrBB.getTerminator()->eraseFromParent();
  Builder.SetInsertPoint(&CurrBB);
  Value *FCmp = TTI->isFCmpOrdCheaperThanFCmpZero(Ty)
                    ? Builder.CreateFCmpORD(Call, Call)
                    : Builder.CreateFCmpOGE(Call->getOperand(0),
                                            ConstantFP::get(Ty, 0.0));
  Builder.CreateCondBr(FCmp, JoinBB, LibCallBB);

// Add phi operands.
  Phi->addIncoming(Call, &CurrBB);
  Phi->addIncoming(LibCall, LibCallBB);

BB = JoinBB->getIterator();
  return true;
}

static bool runPartiallyInlineLibCalls(Function &F, TargetLibraryInfo *TLI,
                                       const TargetTransformInfo *TTI) {
  bool Changed = false;

Function::iterator CurrBB;
  for (Function::iterator BB = F.begin(), BE = F.end(); BB != BE;) {
    CurrBB = BB++;

for (BasicBlock::iterator II = CurrBB->begin(), IE = CurrBB->end();
         II != IE; ++II) {
      CallInst *Call = dyn_cast<CallInst>(&*II);
      Function *CalledFunc;

if (!Call || !(CalledFunc = Call->getCalledFunction()))
        continue;

if (Call->isNoBuiltin())
        continue;

// Skip if function either has local linkage or is not a known library
      // function.
      LibFunc LF;
      if (CalledFunc->hasLocalLinkage() ||
          !TLI->getLibFunc(*CalledFunc, LF) || !TLI->has(LF))
        continue;

switch (LF) {
      case LibFunc_sqrtf:
      case LibFunc_sqrt:
        if (TTI->haveFastSqrt(Call->getType()) &&
            optimizeSQRT(Call, CalledFunc, *CurrBB, BB, TTI))
          break;
        continue;
      default:
        continue;
      }

Changed = true;
      break;
    }
  }

return Changed;
}

PreservedAnalyses
PartiallyInlineLibCallsPass::run(Function &F, FunctionAnalysisManager &AM) {
  auto &TLI = AM.getResult<TargetLibraryAnalysis>(F);
  auto &TTI = AM.getResult<TargetIRAnalysis>(F);
  if (!runPartiallyInlineLibCalls(F, &TLI, &TTI))
    return PreservedAnalyses::all();
  return PreservedAnalyses::none();
}

namespace {
class PartiallyInlineLibCallsLegacyPass : public FunctionPass {
public:
  static char ID;

PartiallyInlineLibCallsLegacyPass() : FunctionPass(ID) {
    initializePartiallyInlineLibCallsLegacyPassPass(
        *PassRegistry::getPassRegistry());
  }

void getAnalysisUsage(AnalysisUsage &AU) const override {
    AU.addRequired<TargetLibraryInfoWrapperPass>();
    AU.addRequired<TargetTransformInfoWrapperPass>();
    FunctionPass::getAnalysisUsage(AU);
  }

bool runOnFunction(Function &F) override {
    if (skipFunction(F))
      return false;

TargetLibraryInfo *TLI =
        &getAnalysis<TargetLibraryInfoWrapperPass>().getTLI(F);
    const TargetTransformInfo *TTI =
        &getAnalysis<TargetTransformInfoWrapperPass>().getTTI(F);
    return runPartiallyInlineLibCalls(F, TLI, TTI);
  }
};
}

char PartiallyInlineLibCallsLegacyPass::ID = 0;
INITIALIZE_PASS_BEGIN(PartiallyInlineLibCallsLegacyPass,
                      "partially-inline-libcalls",
                      "Partially inline calls to library functions", false,
                      false)
INITIALIZE_PASS_DEPENDENCY(TargetLibraryInfoWrapperPass)
INITIALIZE_PASS_DEPENDENCY(TargetTransformInfoWrapperPass)
INITIALIZE_PASS_END(PartiallyInlineLibCallsLegacyPass,
                    "partially-inline-libcalls",
                    "Partially inline calls to library functions", false, false)

FunctionPass *llvm::createPartiallyInlineLibCallsPass() {
  return new PartiallyInlineLibCallsLegacyPass();
}

003 File Manager

Editing: PartiallyInlineLibCalls.cpp

Upload File

Create Folder