llvm/lib/IR/AbstractCallSite.cpp

   1 //===-- AbstractCallSite.cpp - Implementation of abstract call sites ------===//
   2 //
   3 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
   4 // See https://llvm.org/LICENSE.txt for license information.
   5 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
   6 //
   7 //===----------------------------------------------------------------------===//
   8 //
   9 // This file implements abstract call sites which unify the interface for
  10 // direct, indirect, and callback call sites.
  11 //
  12 // For more information see:
  13 // https://llvm.org/devmtg/2018-10/talk-abstracts.html#talk20
  14 //
  15 //===----------------------------------------------------------------------===//
  16
  17 #include "llvm/IR/AbstractCallSite.h"
  18 #include "llvm/ADT/Statistic.h"
  19 #include "llvm/Support/Debug.h"
  20
  21 using namespace llvm;
  22
  23 #define DEBUG_TYPE "abstract-call-sites"
  24
  25 STATISTIC(NumCallbackCallSites, "Number of callback call sites created");
  26 STATISTIC(NumDirectAbstractCallSites,
  27           "Number of direct abstract call sites created");
  28 STATISTIC(NumInvalidAbstractCallSitesUnknownUse,
  29           "Number of invalid abstract call sites created (unknown use)");
  30 STATISTIC(NumInvalidAbstractCallSitesUnknownCallee,
  31           "Number of invalid abstract call sites created (unknown callee)");
  32 STATISTIC(NumInvalidAbstractCallSitesNoCallback,
  33           "Number of invalid abstract call sites created (no callback)");
  34
  35 void AbstractCallSite::getCallbackUses(
  36     const CallBase &CB, SmallVectorImpl<const Use *> &CallbackUses) {
  37   const Function *Callee = CB.getCalledFunction();
  38   if (!Callee)
  39     return;
  40
  41   MDNode *CallbackMD = Callee->getMetadata(LLVMContext::MD_callback);
  42   if (!CallbackMD)
  43     return;
  44
  45   for (const MDOperand &Op : CallbackMD->operands()) {
  46     MDNode *OpMD = cast<MDNode>(Op.get());
  47     auto *CBCalleeIdxAsCM = cast<ConstantAsMetadata>(OpMD->getOperand(0));
  48     uint64_t CBCalleeIdx =
  49         cast<ConstantInt>(CBCalleeIdxAsCM->getValue())->getZExtValue();
  50     if (CBCalleeIdx < CB.arg_size())
  51       CallbackUses.push_back(CB.arg_begin() + CBCalleeIdx);
  52   }
  53 }
  54
  55 /// Create an abstract call site from a use.
  56 AbstractCallSite::AbstractCallSite(const Use *U)
  57     : CB(dyn_cast<CallBase>(U->getUser())) {
  58
  59   // First handle unknown users.
  60   if (!CB) {
  61
  62     // If the use is actually in a constant cast expression which itself
  63     // has only one use, we look through the constant cast expression.
  64     // This happens by updating the use @p U to the use of the constant
  65     // cast expression and afterwards re-initializing CB accordingly.
  66     if (ConstantExpr *CE = dyn_cast<ConstantExpr>(U->getUser()))
  67       if (CE->hasOneUse() && CE->isCast()) {
  68         U = &*CE->use_begin();
  69         CB = dyn_cast<CallBase>(U->getUser());
  70       }
  71
  72     if (!CB) {
  73       NumInvalidAbstractCallSitesUnknownUse++;
  74       return;
  75     }
  76   }
  77
  78   // Then handle direct or indirect calls. Thus, if U is the callee of the
  79   // call site CB it is not a callback and we are done.
  80   if (CB->isCallee(U)) {
  81     NumDirectAbstractCallSites++;
  82     return;
  83   }
  84
  85   // If we cannot identify the broker function we cannot create a callback and
  86   // invalidate the abstract call site.
  87   Function *Callee = CB->getCalledFunction();
  88   if (!Callee) {
  89     NumInvalidAbstractCallSitesUnknownCallee++;
  90     CB = nullptr;
  91     return;
  92   }
  93
  94   MDNode *CallbackMD = Callee->getMetadata(LLVMContext::MD_callback);
  95   if (!CallbackMD) {
  96     NumInvalidAbstractCallSitesNoCallback++;
  97     CB = nullptr;
  98     return;
  99   }
 100
 101   unsigned UseIdx = CB->getArgOperandNo(U);
 102   MDNode *CallbackEncMD = nullptr;
 103   for (const MDOperand &Op : CallbackMD->operands()) {
 104     MDNode *OpMD = cast<MDNode>(Op.get());
 105     auto *CBCalleeIdxAsCM = cast<ConstantAsMetadata>(OpMD->getOperand(0));
 106     uint64_t CBCalleeIdx =
 107         cast<ConstantInt>(CBCalleeIdxAsCM->getValue())->getZExtValue();
 108     if (CBCalleeIdx != UseIdx)
 109       continue;
 110     CallbackEncMD = OpMD;
 111     break;
 112   }
 113
 114   if (!CallbackEncMD) {
 115     NumInvalidAbstractCallSitesNoCallback++;
 116     CB = nullptr;
 117     return;
 118   }
 119
 120   NumCallbackCallSites++;
 121
 122   assert(CallbackEncMD->getNumOperands() >= 2 && "Incomplete !callback metadata");
 123
 124   unsigned NumCallOperands = CB->getNumArgOperands();
 125   // Skip the var-arg flag at the end when reading the metadata.
 126   for (unsigned u = 0, e = CallbackEncMD->getNumOperands() - 1; u < e; u++) {
 127     Metadata *OpAsM = CallbackEncMD->getOperand(u).get();
 128     auto *OpAsCM = cast<ConstantAsMetadata>(OpAsM);
 129     assert(OpAsCM->getType()->isIntegerTy(64) &&
 130            "Malformed !callback metadata");
 131
 132     int64_t Idx = cast<ConstantInt>(OpAsCM->getValue())->getSExtValue();
 133     assert(-1 <= Idx && Idx <= NumCallOperands &&
 134            "Out-of-bounds !callback metadata index");
 135
 136     CI.ParameterEncoding.push_back(Idx);
 137   }
 138
 139   if (!Callee->isVarArg())
 140     return;
 141
 142   Metadata *VarArgFlagAsM =
 143       CallbackEncMD->getOperand(CallbackEncMD->getNumOperands() - 1).get();
 144   auto *VarArgFlagAsCM = cast<ConstantAsMetadata>(VarArgFlagAsM);
 145   assert(VarArgFlagAsCM->getType()->isIntegerTy(1) &&
 146          "Malformed !callback metadata var-arg flag");
 147
 148   if (VarArgFlagAsCM->getValue()->isNullValue())
 149     return;
 150
 151   // Add all variadic arguments at the end.
 152   for (unsigned u = Callee->arg_size(); u < NumCallOperands; u++)
 153     CI.ParameterEncoding.push_back(u);
 154 }