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
getCallbackUses(const CallBase & CB,SmallVectorImpl<const Use * > & CallbackUses)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.
AbstractCallSite(const Use * U)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