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 } 155