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