xref: /freebsd/contrib/llvm-project/llvm/lib/IR/AbstractCallSite.cpp (revision 924226fba12cc9a228c73b956e1b7fa24c60b055)
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->arg_size();
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