include/llvm/IR/GlobalAlias.h

   1 //===-------- llvm/GlobalAlias.h - GlobalAlias 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 GlobalAlias class, which
  11 // represents a single function or variable alias in the IR.
  12 //
  13 //===----------------------------------------------------------------------===//
  14
  15 #ifndef LLVM_IR_GLOBALALIAS_H
  16 #define LLVM_IR_GLOBALALIAS_H
  17
  18 #include "llvm/ADT/Twine.h"
  19 #include "llvm/ADT/ilist_node.h"
  20 #include "llvm/IR/GlobalValue.h"
  21 #include "llvm/IR/OperandTraits.h"
  22
  23 namespace llvm {
  24
  25 class Module;
  26 template <typename ValueSubClass> class SymbolTableListTraits;
  27
  28 class GlobalAlias : public GlobalValue, public ilist_node<GlobalAlias> {
  29   friend class SymbolTableListTraits<GlobalAlias>;
  30   void operator=(const GlobalAlias &) = delete;
  31   GlobalAlias(const GlobalAlias &) = delete;
  32
  33   void setParent(Module *parent);
  34
  35   GlobalAlias(Type *Ty, unsigned AddressSpace, LinkageTypes Linkage,
  36               const Twine &Name, Constant *Aliasee, Module *Parent);
  37
  38 public:
  39   // allocate space for exactly one operand
  40   void *operator new(size_t s) {
  41     return User::operator new(s, 1);
  42   }
  43
  44   /// If a parent module is specified, the alias is automatically inserted into
  45   /// the end of the specified module's alias list.
  46   static GlobalAlias *create(Type *Ty, unsigned AddressSpace,
  47                              LinkageTypes Linkage, const Twine &Name,
  48                              Constant *Aliasee, Module *Parent);
  49
  50   // Without the Aliasee.
  51   static GlobalAlias *create(Type *Ty, unsigned AddressSpace,
  52                              LinkageTypes Linkage, const Twine &Name,
  53                              Module *Parent);
  54
  55   // The module is taken from the Aliasee.
  56   static GlobalAlias *create(Type *Ty, unsigned AddressSpace,
  57                              LinkageTypes Linkage, const Twine &Name,
  58                              GlobalValue *Aliasee);
  59
  60   // Type, Parent and AddressSpace taken from the Aliasee.
  61   static GlobalAlias *create(LinkageTypes Linkage, const Twine &Name,
  62                              GlobalValue *Aliasee);
  63
  64   // Linkage, Type, Parent and AddressSpace taken from the Aliasee.
  65   static GlobalAlias *create(const Twine &Name, GlobalValue *Aliasee);
  66
  67   /// Provide fast operand accessors
  68   DECLARE_TRANSPARENT_OPERAND_ACCESSORS(Constant);
  69
  70   /// removeFromParent - This method unlinks 'this' from the containing module,
  71   /// but does not delete it.
  72   ///
  73   void removeFromParent() override;
  74
  75   /// eraseFromParent - This method unlinks 'this' from the containing module
  76   /// and deletes it.
  77   ///
  78   void eraseFromParent() override;
  79
  80   /// These methods retrive and set alias target.
  81   void setAliasee(Constant *Aliasee);
  82   const Constant *getAliasee() const {
  83     return const_cast<GlobalAlias *>(this)->getAliasee();
  84   }
  85   Constant *getAliasee() {
  86     return getOperand(0);
  87   }
  88
  89   const GlobalObject *getBaseObject() const {
  90     return const_cast<GlobalAlias *>(this)->getBaseObject();
  91   }
  92   GlobalObject *getBaseObject() {
  93     return dyn_cast<GlobalObject>(getAliasee()->stripInBoundsOffsets());
  94   }
  95
  96   const GlobalObject *getBaseObject(const DataLayout &DL, APInt &Offset) const {
  97     return const_cast<GlobalAlias *>(this)->getBaseObject(DL, Offset);
  98   }
  99   GlobalObject *getBaseObject(const DataLayout &DL, APInt &Offset) {
 100     return dyn_cast<GlobalObject>(
 101         getAliasee()->stripAndAccumulateInBoundsConstantOffsets(DL, Offset));
 102   }
 103
 104   static bool isValidLinkage(LinkageTypes L) {
 105     return isExternalLinkage(L) || isLocalLinkage(L) ||
 106       isWeakLinkage(L) || isLinkOnceLinkage(L);
 107   }
 108
 109   // Methods for support type inquiry through isa, cast, and dyn_cast:
 110   static inline bool classof(const Value *V) {
 111     return V->getValueID() == Value::GlobalAliasVal;
 112   }
 113 };
 114
 115 template <>
 116 struct OperandTraits<GlobalAlias> :
 117   public FixedNumOperandTraits<GlobalAlias, 1> {
 118 };
 119
 120 DEFINE_TRANSPARENT_OPERAND_ACCESSORS(GlobalAlias, Constant)
 121
 122 } // End llvm namespace
 123
 124 #endif