EIC code displayed by LXR master/​include/​llvm/​IR/​AbstractCallSite.h	Source navigation Diff markup Identifier search General search
	Version: master test Revert   Change

File indexing completed on 2026-05-10 08:43:56

 //===- AbstractCallSite.h - Abstract call sites -----------------*- C++ -*-===//
 //
 // 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 file defines the AbstractCallSite class, which is a is a wrapper that
 // allows treating direct, indirect, and callback calls the same.
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef LLVM_IR_ABSTRACTCALLSITE_H
 #define LLVM_IR_ABSTRACTCALLSITE_H
 
 #include "llvm/IR/Constants.h"
 #include "llvm/IR/Function.h"
 #include "llvm/IR/InstrTypes.h"
 #include "llvm/IR/Value.h"
 #include <cassert>
 
 namespace llvm {
 
 class Argument;
 class Use;
 
 /// AbstractCallSite
 ///
 /// An abstract call site is a wrapper that allows to treat direct,
 /// indirect, and callback calls the same. If an abstract call site
 /// represents a direct or indirect call site it behaves like a stripped
 /// down version of a normal call site object. The abstract call site can
 /// also represent a callback call, thus the fact that the initially
 /// called function (=broker) may invoke a third one (=callback callee).
 /// In this case, the abstract call site hides the middle man, hence the
 /// broker function. The result is a representation of the callback call,
 /// inside the broker, but in the context of the original call to the broker.
 ///
 /// There are up to three functions involved when we talk about callback call
 /// sites. The caller (1), which invokes the broker function. The broker
 /// function (2), that will invoke the callee zero or more times. And finally
 /// the callee (3), which is the target of the callback call.
 ///
 /// The abstract call site will handle the mapping from parameters to arguments
 /// depending on the semantic of the broker function. However, it is important
 /// to note that the mapping is often partial. Thus, some arguments of the
 /// call/invoke instruction are mapped to parameters of the callee while others
 /// are not.
 class AbstractCallSite {
 public:
 
   /// The encoding of a callback with regards to the underlying instruction.
   struct CallbackInfo {
 
     /// For direct/indirect calls the parameter encoding is empty. If it is not,
     /// the abstract call site represents a callback. In that case, the first
     /// element of the encoding vector represents which argument of the call
     /// site CB is the callback callee. The remaining elements map parameters
     /// (identified by their position) to the arguments that will be passed
     /// through (also identified by position but in the call site instruction).
     ///
     /// NOTE that we use LLVM argument numbers (starting at 0) and not
     /// clang/source argument numbers (starting at 1). The -1 entries represent
     /// unknown values that are passed to the callee.
     using ParameterEncodingTy = SmallVector<int, 0>;
     ParameterEncodingTy ParameterEncoding;
 
   };
 
 private:
 
   /// The underlying call site:
   ///   caller -> callee,             if this is a direct or indirect call site
   ///   caller -> broker function,    if this is a callback call site
   CallBase *CB;
 
   /// The encoding of a callback with regards to the underlying instruction.
   CallbackInfo CI;
 
 public:
   /// Sole constructor for abstract call sites (ACS).
   ///
   /// An abstract call site can only be constructed through a llvm::Use because
   /// each operand (=use) of an instruction could potentially be a different
   /// abstract call site. Furthermore, even if the value of the llvm::Use is the
   /// same, and the user is as well, the abstract call sites might not be.
   ///
   /// If a use is not associated with an abstract call site the constructed ACS
   /// will evaluate to false if converted to a boolean.
   ///
   /// If the use is the callee use of a call or invoke instruction, the
   /// constructed abstract call site will behave as a llvm::CallSite would.
   ///
   /// If the use is not a callee use of a call or invoke instruction, the
   /// callback metadata is used to determine the argument <-> parameter mapping
   /// as well as the callee of the abstract call site.
   AbstractCallSite(const Use *U);
 
   /// Add operand uses of \p CB that represent callback uses into
   /// \p CallbackUses.
   ///
   /// All uses added to \p CallbackUses can be used to create abstract call
   /// sites for which AbstractCallSite::isCallbackCall() will return true.
   static void getCallbackUses(const CallBase &CB,
                               SmallVectorImpl<const Use *> &CallbackUses);
 
   /// Conversion operator to conveniently check for a valid/initialized ACS.
   explicit operator bool() const { return CB != nullptr; }
 
   /// Return the underlying instruction.
   CallBase *getInstruction() const { return CB; }
 
   /// Return true if this ACS represents a direct call.
   bool isDirectCall() const {
     return !isCallbackCall() && !CB->isIndirectCall();
   }
 
   /// Return true if this ACS represents an indirect call.
   bool isIndirectCall() const {
     return !isCallbackCall() && CB->isIndirectCall();
   }
 
   /// Return true if this ACS represents a callback call.
   bool isCallbackCall() const {
     // For a callback call site the callee is ALWAYS stored first in the
     // transitive values vector. Thus, a non-empty vector indicates a callback.
     return !CI.ParameterEncoding.empty();
   }
 
   /// Return true if @p UI is the use that defines the callee of this ACS.
   bool isCallee(Value::const_user_iterator UI) const {
     return isCallee(&UI.getUse());
   }
 
   /// Return true if @p U is the use that defines the callee of this ACS.
   bool isCallee(const Use *U) const {
     if (isDirectCall())
       return CB->isCallee(U);
 
     assert(!CI.ParameterEncoding.empty() &&
            "Callback without parameter encoding!");
 
     // If the use is actually in a constant cast expression which itself
     // has only one use, we look through the constant cast expression.
     if (auto *CE = dyn_cast<ConstantExpr>(U->getUser()))
       if (CE->hasOneUse() && CE->isCast())
         U = &*CE->use_begin();
 
     return (int)CB->getArgOperandNo(U) == CI.ParameterEncoding[0];
   }
 
   /// Return the number of parameters of the callee.
   unsigned getNumArgOperands() const {
     if (isDirectCall())
       return CB->arg_size();
     // Subtract 1 for the callee encoding.
     return CI.ParameterEncoding.size() - 1;
   }
 
   /// Return the operand index of the underlying instruction associated with @p
   /// Arg.
   int getCallArgOperandNo(Argument &Arg) const {
     return getCallArgOperandNo(Arg.getArgNo());
   }
 
   /// Return the operand index of the underlying instruction associated with
   /// the function parameter number @p ArgNo or -1 if there is none.
   int getCallArgOperandNo(unsigned ArgNo) const {
     if (isDirectCall())
       return ArgNo;
     // Add 1 for the callee encoding.
     return CI.ParameterEncoding[ArgNo + 1];
   }
 
   /// Return the operand of the underlying instruction associated with @p Arg.
   Value *getCallArgOperand(Argument &Arg) const {
     return getCallArgOperand(Arg.getArgNo());
   }
 
   /// Return the operand of the underlying instruction associated with the
   /// function parameter number @p ArgNo or nullptr if there is none.
   Value *getCallArgOperand(unsigned ArgNo) const {
     if (isDirectCall())
       return CB->getArgOperand(ArgNo);
     // Add 1 for the callee encoding.
     return CI.ParameterEncoding[ArgNo + 1] >= 0
                ? CB->getArgOperand(CI.ParameterEncoding[ArgNo + 1])
                : nullptr;
   }
 
   /// Return the operand index of the underlying instruction associated with the
   /// callee of this ACS. Only valid for callback calls!
   int getCallArgOperandNoForCallee() const {
     assert(isCallbackCall());
     assert(CI.ParameterEncoding.size() && CI.ParameterEncoding[0] >= 0);
     return CI.ParameterEncoding[0];
   }
 
   /// Return the use of the callee value in the underlying instruction. Only
   /// valid for callback calls!
   const Use &getCalleeUseForCallback() const {
     int CalleeArgIdx = getCallArgOperandNoForCallee();
     assert(CalleeArgIdx >= 0 &&
            unsigned(CalleeArgIdx) < getInstruction()->getNumOperands());
     return getInstruction()->getOperandUse(CalleeArgIdx);
   }
 
   /// Return the pointer to function that is being called.
   Value *getCalledOperand() const {
     if (isDirectCall())
       return CB->getCalledOperand();
     return CB->getArgOperand(getCallArgOperandNoForCallee());
   }
 
   /// Return the function being called if this is a direct call, otherwise
   /// return null (if it's an indirect call).
   Function *getCalledFunction() const {
     Value *V = getCalledOperand();
     return V ? dyn_cast<Function>(V->stripPointerCasts()) : nullptr;
   }
 };
 
 /// Apply function Func to each CB's callback call site.
 template <typename UnaryFunction>
 void forEachCallbackCallSite(const CallBase &CB, UnaryFunction Func) {
   SmallVector<const Use *, 4u> CallbackUses;
   AbstractCallSite::getCallbackUses(CB, CallbackUses);
   for (const Use *U : CallbackUses) {
     AbstractCallSite ACS(U);
     assert(ACS && ACS.isCallbackCall() && "must be a callback call");
     Func(ACS);
   }
 }
 
 /// Apply function Func to each CB's callback function.
 template <typename UnaryFunction>
 void forEachCallbackFunction(const CallBase &CB, UnaryFunction Func) {
   forEachCallbackCallSite(CB, [&Func](AbstractCallSite &ACS) {
     if (Function *Callback = ACS.getCalledFunction())
       Func(Callback);
   });
 }
 
 } // end namespace llvm
 
 #endif // LLVM_IR_ABSTRACTCALLSITE_H

This page was automatically generated by the 2.3.7 LXR engine. The LXR team