add a new code

[oota-llvm.git] / include / llvm / GlobalValue.h

diff --git a/include/llvm/GlobalValue.h b/include/llvm/GlobalValue.h
index 6aa830e62833a7b623fbd09f2df61811bb81d4d5..317aa486a4070d9b2cf84a630796c3d2ff552b0a 100644 (file)
--- a/include/llvm/GlobalValue.h
+++ b/include/llvm/GlobalValue.h
@@ -27,27 +27,40 @@ class Module;
 class GlobalValue : public Constant {
   GlobalValue(const GlobalValue &);             // do not implement
 public:
+  /// @brief An enumeration for the kinds of linkage for global values.
   enum LinkageTypes {
-    ExternalLinkage,     /// Externally visible function
-    LinkOnceLinkage,     /// Keep one copy of named function when linking (inline)
-    WeakLinkage,         /// Keep one copy of named function when linking (weak)
-    AppendingLinkage,    /// Special purpose, only applies to global arrays
-    InternalLinkage,     /// Rename collisions when linking (static functions)
-    DLLImportLinkage,    /// Function to be imported from DLL
-    DLLExportLinkage,    /// Function to be accessible from DLL
-    ExternalWeakLinkage, /// TBD: ExternalWeak linkage description
-    GhostLinkage         /// Stand-in functions for streaming fns from BC files    
+    ExternalLinkage = 0,///< Externally visible function
+    LinkOnceLinkage,    ///< Keep one copy of function when linking (inline)
+    WeakLinkage,        ///< Keep one copy of named function when linking (weak)
+    AppendingLinkage,   ///< Special purpose, only applies to global arrays
+    InternalLinkage,    ///< Rename collisions when linking (static functions)
+    DLLImportLinkage,   ///< Function to be imported from DLL
+    DLLExportLinkage,   ///< Function to be accessible from DLL
+    ExternalWeakLinkage,///< ExternalWeak linkage description
+    GhostLinkage        ///< Stand-in functions for streaming fns from BC files    
   };
+
+  /// @brief An enumeration for the kinds of visibility of global values.
+  enum VisibilityTypes {
+    DefaultVisibility = 0,  ///< The GV is visible
+    HiddenVisibility        ///< The GV is hidden
+  };
+
 protected:
   GlobalValue(const Type *Ty, ValueTy vty, Use *Ops, unsigned NumOps,
               LinkageTypes linkage, const std::string &name = "")
-    : Constant(Ty, vty, Ops, NumOps, name), 
-      Parent(0), Linkage(linkage), Alignment(0) { }
+    : Constant(Ty, vty, Ops, NumOps), Parent(0),
+      Linkage(linkage), Visibility(DefaultVisibility), Alignment(0) {
+    if (!name.empty()) setName(name);
+  }
 
   Module *Parent;
-  LinkageTypes Linkage;   // The linkage of this global
-  unsigned Alignment;     // Alignment of this symbol, must be power of two
-  std::string Section;    // Section to emit this into, empty mean default
+  // Note: VC++ treats enums as signed, so an extra bit is required to prevent
+  // Linkage and Visibility from turning into negative values.
+  LinkageTypes Linkage : 5;   // The linkage of this global
+  unsigned Visibility : 1;    // The visibility style of this global
+  unsigned Alignment : 16;    // Alignment of this symbol, must be power of two
+  std::string Section;        // Section to emit this into, empty mean default
 public:
   ~GlobalValue() {
     removeDeadConstantUsers();   // remove any dead constants using this.
@@ -58,6 +71,10 @@ public:
     assert((Align & (Align-1)) == 0 && "Alignment is not a power of 2!");
     Alignment = Align;
   }
+
+  VisibilityTypes getVisibility() const { return (VisibilityTypes)Visibility; }
+  bool hasHiddenVisibility() const { return Visibility == HiddenVisibility; }
+  void setVisibility(VisibilityTypes V) { Visibility = V; }
   
   bool hasSection() const { return !Section.empty(); }
   const std::string &getSection() const { return Section; }
@@ -82,7 +99,7 @@ public:
   bool hasInternalLinkage()   const { return Linkage == InternalLinkage; }
   bool hasDLLImportLinkage()  const { return Linkage == DLLImportLinkage; }
   bool hasDLLExportLinkage()  const { return Linkage == DLLExportLinkage; }
-  bool hasExternalWeakLinkage()  const { return Linkage == ExternalWeakLinkage; }
+  bool hasExternalWeakLinkage() const { return Linkage == ExternalWeakLinkage; }
   void setLinkage(LinkageTypes LT) { Linkage = LT; }
   LinkageTypes getLinkage() const { return Linkage; }
 
@@ -100,9 +117,19 @@ public:
   /// Override from Constant class.
   virtual void destroyConstant();
 
-  /// isExternal - Return true if the primary definition of this global value is
-  /// outside of the current translation unit...
-  virtual bool isExternal() const = 0;
+  /// isDeclaration - Return true if the primary definition of this global 
+  /// value is outside of the current translation unit...
+  virtual bool isDeclaration() const = 0;
+
+  /// removeFromParent - This method unlinks 'this' from the containing module,
+  /// but does not delete it.
+  ///
+  virtual void removeFromParent() = 0;
+
+  /// eraseFromParent - This method unlinks 'this' from the containing module
+  /// and deletes it.
+  ///
+  virtual void eraseFromParent() = 0;
 
   /// getParent - Get the module that this global value is contained inside
   /// of...
@@ -113,17 +140,14 @@ public:
   /// off of this global value, remove them.  This method is useful for clients
   /// that want to check to see if a global is unused, but don't want to deal
   /// with potentially dead constants hanging off of the globals.
-  ///
-  /// This method tries to make the global dead.  If it detects a user that
-  /// would prevent it from becoming completely dead, it gives up early,
-  /// potentially leaving some dead constant users around.
   void removeDeadConstantUsers();
 
   // Methods for support type inquiry through isa, cast, and dyn_cast:
   static inline bool classof(const GlobalValue *) { return true; }
   static inline bool classof(const Value *V) {
-    return V->getValueType() == Value::FunctionVal ||
-           V->getValueType() == Value::GlobalVariableVal;
+    return V->getValueID() == Value::FunctionVal ||
+           V->getValueID() == Value::GlobalVariableVal ||
+           V->getValueID() == Value::GlobalAliasVal;
   }
 };