1 //===- llvm/GlobalIndirectSymbol.h - GlobalIndirectSymbol 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 // This file contains the declaration of the GlobalIndirectSymbol class, which 10 // is a base class for GlobalAlias and GlobalIFunc. It contains all common code 11 // for aliases and ifuncs. 12 // 13 //===----------------------------------------------------------------------===// 14 15 #ifndef LLVM_IR_GLOBALINDIRECTSYMBOL_H 16 #define LLVM_IR_GLOBALINDIRECTSYMBOL_H 17 18 #include "llvm/IR/GlobalObject.h" 19 #include "llvm/IR/GlobalValue.h" 20 #include "llvm/IR/OperandTraits.h" 21 #include "llvm/IR/User.h" 22 #include "llvm/IR/Value.h" 23 #include "llvm/Support/Casting.h" 24 #include <cstddef> 25 26 namespace llvm { 27 28 class GlobalIndirectSymbol : public GlobalValue { 29 protected: 30 GlobalIndirectSymbol(Type *Ty, ValueTy VTy, unsigned AddressSpace, 31 LinkageTypes Linkage, const Twine &Name, Constant *Symbol); 32 33 public: 34 GlobalIndirectSymbol(const GlobalIndirectSymbol &) = delete; 35 GlobalIndirectSymbol &operator=(const GlobalIndirectSymbol &) = delete; 36 37 // allocate space for exactly one operand new(size_t s)38 void *operator new(size_t s) { 39 return User::operator new(s, 1); 40 } 41 42 /// Provide fast operand accessors 43 DECLARE_TRANSPARENT_OPERAND_ACCESSORS(Constant); 44 copyAttributesFrom(const GlobalValue * Src)45 void copyAttributesFrom(const GlobalValue *Src) { 46 GlobalValue::copyAttributesFrom(Src); 47 } 48 49 /// These methods set and retrieve indirect symbol. setIndirectSymbol(Constant * Symbol)50 void setIndirectSymbol(Constant *Symbol) { 51 setOperand(0, Symbol); 52 } getIndirectSymbol()53 const Constant *getIndirectSymbol() const { 54 return getOperand(0); 55 } getIndirectSymbol()56 Constant *getIndirectSymbol() { 57 return const_cast<Constant *>( 58 static_cast<const GlobalIndirectSymbol *>(this)->getIndirectSymbol()); 59 } 60 61 const GlobalObject *getBaseObject() const; getBaseObject()62 GlobalObject *getBaseObject() { 63 return const_cast<GlobalObject *>( 64 static_cast<const GlobalIndirectSymbol *>(this)->getBaseObject()); 65 } 66 getBaseObject(const DataLayout & DL,APInt & Offset)67 const GlobalObject *getBaseObject(const DataLayout &DL, APInt &Offset) const { 68 return dyn_cast<GlobalObject>( 69 getIndirectSymbol()->stripAndAccumulateInBoundsConstantOffsets(DL, 70 Offset)); 71 } getBaseObject(const DataLayout & DL,APInt & Offset)72 GlobalObject *getBaseObject(const DataLayout &DL, APInt &Offset) { 73 return const_cast<GlobalObject *>( 74 static_cast<const GlobalIndirectSymbol *>(this) 75 ->getBaseObject(DL, Offset)); 76 } 77 78 // Methods for support type inquiry through isa, cast, and dyn_cast: classof(const Value * V)79 static bool classof(const Value *V) { 80 return V->getValueID() == Value::GlobalAliasVal || 81 V->getValueID() == Value::GlobalIFuncVal; 82 } 83 }; 84 85 template <> 86 struct OperandTraits<GlobalIndirectSymbol> : 87 public FixedNumOperandTraits<GlobalIndirectSymbol, 1> { 88 }; 89 90 DEFINE_TRANSPARENT_OPERAND_ACCESSORS(GlobalIndirectSymbol, Constant) 91 92 } // end namespace llvm 93 94 #endif // LLVM_IR_GLOBALINDIRECTSYMBOL_H 95