Subversion Repositories QNX 8.QNX8 LLVM/Clang compiler suite

Rev

Blame | Last modification | View Log | Download | RSS feed

  1. //===-------- llvm/GlobalIFunc.h - GlobalIFunc class ------------*- C++ -*-===//
  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. /// \file
  10. /// This file contains the declaration of the GlobalIFunc class, which
  11. /// represents a single indirect function in the IR. Indirect function uses
  12. /// ELF symbol type extension to mark that the address of a declaration should
  13. /// be resolved at runtime by calling a resolver function.
  14. ///
  15. //===----------------------------------------------------------------------===//
  16.  
  17. #ifndef LLVM_IR_GLOBALIFUNC_H
  18. #define LLVM_IR_GLOBALIFUNC_H
  19.  
  20. #include "llvm/ADT/ilist_node.h"
  21. #include "llvm/IR/Constant.h"
  22. #include "llvm/IR/GlobalObject.h"
  23. #include "llvm/IR/OperandTraits.h"
  24. #include "llvm/IR/Value.h"
  25.  
  26. namespace llvm {
  27.  
  28. class Twine;
  29. class Module;
  30.  
  31. // Traits class for using GlobalIFunc in symbol table in Module.
  32. template <typename ValueSubClass> class SymbolTableListTraits;
  33.  
  34. class GlobalIFunc final : public GlobalObject, public ilist_node<GlobalIFunc> {
  35.   friend class SymbolTableListTraits<GlobalIFunc>;
  36.  
  37.   GlobalIFunc(Type *Ty, unsigned AddressSpace, LinkageTypes Linkage,
  38.               const Twine &Name, Constant *Resolver, Module *Parent);
  39.  
  40. public:
  41.   GlobalIFunc(const GlobalIFunc &) = delete;
  42.   GlobalIFunc &operator=(const GlobalIFunc &) = delete;
  43.  
  44.   /// If a parent module is specified, the ifunc is automatically inserted into
  45.   /// the end of the specified module's ifunc list.
  46.   static GlobalIFunc *create(Type *Ty, unsigned AddressSpace,
  47.                              LinkageTypes Linkage, const Twine &Name,
  48.                              Constant *Resolver, Module *Parent);
  49.  
  50.   // allocate space for exactly one operand
  51.   void *operator new(size_t S) { return User::operator new(S, 1); }
  52.   void operator delete(void *Ptr) { User::operator delete(Ptr); }
  53.  
  54.   /// Provide fast operand accessors
  55.   DECLARE_TRANSPARENT_OPERAND_ACCESSORS(Constant);
  56.  
  57.   void copyAttributesFrom(const GlobalIFunc *Src) {
  58.     GlobalObject::copyAttributesFrom(Src);
  59.   }
  60.  
  61.   /// This method unlinks 'this' from the containing module, but does not
  62.   /// delete it.
  63.   void removeFromParent();
  64.  
  65.   /// This method unlinks 'this' from the containing module and deletes it.
  66.   void eraseFromParent();
  67.  
  68.   /// These methods retrieve and set ifunc resolver function.
  69.   void setResolver(Constant *Resolver) { Op<0>().set(Resolver); }
  70.   const Constant *getResolver() const {
  71.     return static_cast<Constant *>(Op<0>().get());
  72.   }
  73.   Constant *getResolver() { return static_cast<Constant *>(Op<0>().get()); }
  74.  
  75.   // Return the resolver function after peeling off potential ConstantExpr
  76.   // indirection.
  77.   const Function *getResolverFunction() const;
  78.   Function *getResolverFunction() {
  79.     return const_cast<Function *>(
  80.         static_cast<const GlobalIFunc *>(this)->getResolverFunction());
  81.   }
  82.  
  83.   static FunctionType *getResolverFunctionType(Type *IFuncValTy) {
  84.     return FunctionType::get(IFuncValTy->getPointerTo(), false);
  85.   }
  86.  
  87.   static bool isValidLinkage(LinkageTypes L) {
  88.     return isExternalLinkage(L) || isLocalLinkage(L) || isWeakLinkage(L) ||
  89.            isLinkOnceLinkage(L);
  90.   }
  91.  
  92.   // Methods for support type inquiry through isa, cast, and dyn_cast:
  93.   static bool classof(const Value *V) {
  94.     return V->getValueID() == Value::GlobalIFuncVal;
  95.   }
  96.  
  97.   // Apply specific operation to all resolver-related values. If resolver target
  98.   // is already a global object, then apply the operation to it directly. If
  99.   // target is a GlobalExpr or a GlobalAlias, evaluate it to its base object and
  100.   // apply the operation for the base object and all aliases along the path.
  101.   void applyAlongResolverPath(function_ref<void(const GlobalValue &)> Op) const;
  102. };
  103.  
  104. template <>
  105. struct OperandTraits<GlobalIFunc>
  106.     : public FixedNumOperandTraits<GlobalIFunc, 1> {};
  107.  
  108. DEFINE_TRANSPARENT_OPERAND_ACCESSORS(GlobalIFunc, Constant)
  109.  
  110. } // end namespace llvm
  111.  
  112. #endif // LLVM_IR_GLOBALIFUNC_H
  113.