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, typename... Args> 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