Home | History | Annotate | Download | only in llvm 
      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_GLOBAL_ALIAS_H
     16 #define LLVM_GLOBAL_ALIAS_H
     17 
     18 #include "llvm/GlobalValue.h"
     19 #include "llvm/OperandTraits.h"
     20 #include "llvm/ADT/ilist_node.h"
     21 #include "llvm/ADT/Twine.h"
     22 
     23 namespace llvm {
     24 
     25 class Module;
     26 template<typename ValueSubClass, typename ItemParentClass>
     27   class SymbolTableListTraits;
     28 
     29 class GlobalAlias : public GlobalValue, public ilist_node<GlobalAlias> {
     30   friend class SymbolTableListTraits<GlobalAlias, Module>;
     31   void operator=(const GlobalAlias &);     // Do not implement
     32   GlobalAlias(const GlobalAlias &);     // Do not implement
     33 
     34   void setParent(Module *parent);
     35 
     36 public:
     37   // allocate space for exactly one operand
     38   void *operator new(size_t s) {
     39     return User::operator new(s, 1);
     40   }
     41   /// GlobalAlias ctor - If a parent module is specified, the alias is
     42   /// automatically inserted into the end of the specified module's alias list.
     43   GlobalAlias(Type *Ty, LinkageTypes Linkage, const Twine &Name = "",
     44               Constant* Aliasee = 0, Module *Parent = 0);
     45 
     46   /// Provide fast operand accessors
     47   DECLARE_TRANSPARENT_OPERAND_ACCESSORS(Constant);
     48 
     49   /// removeFromParent - This method unlinks 'this' from the containing module,
     50   /// but does not delete it.
     51   ///
     52   virtual void removeFromParent();
     53 
     54   /// eraseFromParent - This method unlinks 'this' from the containing module
     55   /// and deletes it.
     56   ///
     57   virtual void eraseFromParent();
     58 
     59   /// set/getAliasee - These methods retrive and set alias target.
     60   void setAliasee(Constant *GV);
     61   const Constant *getAliasee() const {
     62     return getOperand(0);
     63   }
     64   Constant *getAliasee() {
     65     return getOperand(0);
     66   }
     67   /// getAliasedGlobal() - Aliasee can be either global or bitcast of
     68   /// global. This method retrives the global for both aliasee flavours.
     69   const GlobalValue *getAliasedGlobal() const;
     70 
     71   /// resolveAliasedGlobal() - This method tries to ultimately resolve the alias
     72   /// by going through the aliasing chain and trying to find the very last
     73   /// global. Returns NULL if a cycle was found. If stopOnWeak is false, then
     74   /// the whole chain aliasing chain is traversed, otherwise - only strong
     75   /// aliases.
     76   const GlobalValue *resolveAliasedGlobal(bool stopOnWeak = true) const;
     77 
     78   // Methods for support type inquiry through isa, cast, and dyn_cast:
     79   static inline bool classof(const GlobalAlias *) { return true; }
     80   static inline bool classof(const Value *V) {
     81     return V->getValueID() == Value::GlobalAliasVal;
     82   }
     83 };
     84 
     85 template <>
     86 struct OperandTraits<GlobalAlias> :
     87   public FixedNumOperandTraits<GlobalAlias, 1> {
     88 };
     89 
     90 DEFINE_TRANSPARENT_OPERAND_ACCESSORS(GlobalAlias, Constant)
     91 
     92 } // End llvm namespace
     93 
     94 #endif
     95