Line data    Source code

       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           0 : 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
      39             :   void *operator new(size_t s) {
      40        3246 :     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.
      47             :   void setIndirectSymbol(Constant *Symbol) {
      48             :     setOperand(0, Symbol);
      49             :   }
      50             :   const Constant *getIndirectSymbol() const {
      51             :     return getOperand(0);
      52             :   }
      53             :   Constant *getIndirectSymbol() {
      54             :     return const_cast<Constant *>(
      55             :           static_cast<const GlobalIndirectSymbol *>(this)->getIndirectSymbol());
      56             :   }
      57             : 
      58       10201 :   const GlobalObject *getBaseObject() const {
      59       10201 :     return dyn_cast<GlobalObject>(getIndirectSymbol()->stripInBoundsOffsets());
      60             :   }
      61             :   GlobalObject *getBaseObject() {
      62             :     return const_cast<GlobalObject *>(
      63          61 :               static_cast<const GlobalIndirectSymbol *>(this)->getBaseObject());
      64             :   }
      65             : 
      66             :   const GlobalObject *getBaseObject(const DataLayout &DL, APInt &Offset) const {
      67             :     return dyn_cast<GlobalObject>(
      68             :         getIndirectSymbol()->stripAndAccumulateInBoundsConstantOffsets(DL,
      69             :                                                                        Offset));
      70             :   }
      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:
      78             :   static bool classof(const Value *V) {
      79        1090 :     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       27792 : DEFINE_TRANSPARENT_OPERAND_ACCESSORS(GlobalIndirectSymbol, Constant)
      90             : 
      91             : } // end namespace llvm
      92             : 
      93             : #endif // LLVM_IR_GLOBALINDIRECTSYMBOL_H