include/llvm/IR/GlobalIndirectSymbol.h

   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
  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
  45   /// These methods set and retrieve indirect symbol.
  46   void setIndirectSymbol(Constant *Symbol) {
  47     setOperand(0, Symbol);
  48   }
  49   const Constant *getIndirectSymbol() const {
  50     return getOperand(0);
  51   }
  52   Constant *getIndirectSymbol() {
  53     return const_cast<Constant *>(
  54           static_cast<const GlobalIndirectSymbol *>(this)->getIndirectSymbol());
  55   }
  56
  57   const GlobalObject *getBaseObject() const {
  58     return dyn_cast<GlobalObject>(getIndirectSymbol()->stripInBoundsOffsets());
  59   }
  60   GlobalObject *getBaseObject() {
  61     return const_cast<GlobalObject *>(
  62               static_cast<const GlobalIndirectSymbol *>(this)->getBaseObject());
  63   }
  64
  65   const GlobalObject *getBaseObject(const DataLayout &DL, APInt &Offset) const {
  66     return dyn_cast<GlobalObject>(
  67         getIndirectSymbol()->stripAndAccumulateInBoundsConstantOffsets(DL,
  68                                                                        Offset));
  69   }
  70   GlobalObject *getBaseObject(const DataLayout &DL, APInt &Offset) {
  71     return const_cast<GlobalObject *>(
  72                                  static_cast<const GlobalIndirectSymbol *>(this)
  73                                    ->getBaseObject(DL, Offset));
  74   }
  75
  76   // Methods for support type inquiry through isa, cast, and dyn_cast:
  77   static bool classof(const Value *V) {
  78     return V->getValueID() == Value::GlobalAliasVal ||
  79            V->getValueID() == Value::GlobalIFuncVal;
  80   }
  81 };
  82
  83 template <>
  84 struct OperandTraits<GlobalIndirectSymbol> :
  85   public FixedNumOperandTraits<GlobalIndirectSymbol, 1> {
  86 };
  87
  88 DEFINE_TRANSPARENT_OPERAND_ACCESSORS(GlobalIndirectSymbol, Constant)
  89
  90 } // end namespace llvm
  91
  92 #endif // LLVM_IR_GLOBALINDIRECTSYMBOL_H