X-Git-Url: http://demsky.eecs.uci.edu/git/?a=blobdiff_plain;f=include%2Fllvm%2FGlobalAlias.h;h=164d976588d6c58ac9253b03aaf9ea5d05ca3009;hb=f9ef3b6e9eb0218477de2d1e8d0820263524670b;hp=ec6ea77060529f44e5d19456992169d8049605bc;hpb=7bc428fa6f182f5adf04ff62d72370091f64beeb;p=oota-llvm.git

diff --git a/include/llvm/GlobalAlias.h b/include/llvm/GlobalAlias.h
index ec6ea770605..164d976588d 100644
--- a/include/llvm/GlobalAlias.h
+++ b/include/llvm/GlobalAlias.h
@@ -1,14 +1,14 @@
-//===______-- llvm/GlobalAlias.h - GlobalAlias class ------------*- C++ -*-===//
+//===-------- llvm/GlobalAlias.h - GlobalAlias class ------------*- C++ -*-===//
 //
 //                     The LLVM Compiler Infrastructure
 //
-// This file was developed by Anton Korobeynikov and is distributed under
-// the University of Illinois Open Source License. See LICENSE.TXT for details.
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 //
 // This file contains the declaration of the GlobalAlias class, which
-// represents a single function or variable alias in the VM.
+// represents a single function or variable alias in the IR.
 //
 //===----------------------------------------------------------------------===//
 
@@ -16,38 +16,35 @@
 #define LLVM_GLOBAL_ALIAS_H
 
 #include "llvm/GlobalValue.h"
+#include "llvm/OperandTraits.h"
+#include "llvm/ADT/ilist_node.h"
+#include "llvm/ADT/Twine.h"
 
 namespace llvm {
 
 class Module;
-class Constant;
-class PointerType;
 template<typename ValueSubClass, typename ItemParentClass>
   class SymbolTableListTraits;
 
-class GlobalAlias : public GlobalValue {
+class GlobalAlias : public GlobalValue, public ilist_node<GlobalAlias> {
   friend class SymbolTableListTraits<GlobalAlias, Module>;
   void operator=(const GlobalAlias &);     // Do not implement
   GlobalAlias(const GlobalAlias &);     // Do not implement
 
   void setParent(Module *parent);
 
-  GlobalAlias *Prev, *Next;
-  void setNext(GlobalAlias *N) { Next = N; }
-  void setPrev(GlobalAlias *N) { Prev = N; }
-
-  const GlobalValue* Aliasee;
-  std::string Target;
 public:
+  // allocate space for exactly one operand
+  void *operator new(size_t s) {
+    return User::operator new(s, 1);
+  }
   /// GlobalAlias ctor - If a parent module is specified, the alias is
-  /// automatically inserted into the end of the specified modules alias list.
-  GlobalAlias(const Type *Ty, LinkageTypes Linkage, const std::string &Name = "",
-              const GlobalValue* Aliasee = 0, Module *Parent = 0);
+  /// automatically inserted into the end of the specified module's alias list.
+  GlobalAlias(Type *Ty, LinkageTypes Linkage, const Twine &Name = "",
+              Constant* Aliasee = 0, Module *Parent = 0);
 
-  /// isDeclaration - Is this global variable lacking an initializer?  If so, 
-  /// the global variable is defined in some other translation unit, and is thus
-  /// only a declaration here.
-  virtual bool isDeclaration() const;
+  /// Provide fast operand accessors
+  DECLARE_TRANSPARENT_OPERAND_ACCESSORS(Constant);
 
   /// removeFromParent - This method unlinks 'this' from the containing module,
   /// but does not delete it.
@@ -59,25 +56,39 @@ public:
   ///
   virtual void eraseFromParent();
 
-  virtual void print(std::ostream &OS) const;
-  void print(std::ostream *OS) const { if (OS) print(*OS); }
+  /// set/getAliasee - These methods retrive and set alias target.
+  void setAliasee(Constant *GV);
+  const Constant *getAliasee() const {
+    return getOperand(0);
+  }
+  Constant *getAliasee() {
+    return getOperand(0);
+  }
+  /// getAliasedGlobal() - Aliasee can be either global or bitcast of
+  /// global. This method retrives the global for both aliasee flavours.
+  const GlobalValue *getAliasedGlobal() const;
 
-  void setAliasee(const GlobalValue* GV);
-  const GlobalValue* getAliasee() const { return Aliasee; }
+  /// resolveAliasedGlobal() - This method tries to ultimately resolve the alias
+  /// by going through the aliasing chain and trying to find the very last
+  /// global. Returns NULL if a cycle was found. If stopOnWeak is false, then
+  /// the whole chain aliasing chain is traversed, otherwise - only strong
+  /// aliases.
+  const GlobalValue *resolveAliasedGlobal(bool stopOnWeak = true) const;
 
   // Methods for support type inquiry through isa, cast, and dyn_cast:
   static inline bool classof(const GlobalAlias *) { return true; }
   static inline bool classof(const Value *V) {
     return V->getValueID() == Value::GlobalAliasVal;
   }
-private:
-  // getNext/Prev - Return the next or previous alias in the list.
-        GlobalAlias *getNext()       { return Next; }
-  const GlobalAlias *getNext() const { return Next; }
-        GlobalAlias *getPrev()       { return Prev; }
-  const GlobalAlias *getPrev() const { return Prev; }
 };
 
+template <>
+struct OperandTraits<GlobalAlias> :
+  public FixedNumOperandTraits<GlobalAlias, 1> {
+};
+
+DEFINE_TRANSPARENT_OPERAND_ACCESSORS(GlobalAlias, Constant)
+
 } // End llvm namespace
 
 #endif