Add an extra operand to LABEL nodes which distinguishes between debug, EH, or misc...

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

diff --git a/include/llvm/AbstractTypeUser.h b/include/llvm/AbstractTypeUser.h
index 2b6bc3194964454c7367189918331dd340f920a2..f7fabfcb2fe4b4fa18559eb0130ae13019907e3a 100644 (file)
--- a/include/llvm/AbstractTypeUser.h
+++ b/include/llvm/AbstractTypeUser.h
@@ -2,32 +2,24 @@
 //
 //                     The LLVM Compiler Infrastructure
 //
-// This file was developed by the LLVM research group 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.
 //
 //===----------------------------------------------------------------------===//
 //
-// The AbstractTypeUser class is an interface to be implemented by classes who
-// could possible use an abstract type.  Abstract types are denoted by the
-// isAbstract flag set to true in the Type class.  These are classes that
-// contain an Opaque type in their structure somehow.
-//
-// Classes must implement this interface so that they may be notified when an
-// abstract type is resolved.  Abstract types may be resolved into more concrete
-// types through: linking, parsing, and bytecode reading.  When this happens,
-// all of the users of the type must be updated to reference the new, more
-// concrete type.  They are notified through the AbstractTypeUser interface.
-//
-// In addition to this, AbstractTypeUsers must keep the use list of the
-// potentially abstract type that they reference up-to-date.  To do this in a
-// nice, transparent way, the PATypeHandle class is used to hold "Potentially
-// Abstract Types", and keep the use list of the abstract types up-to-date.
+// This file declares the AbstractTypeUser class.
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef LLVM_ABSTRACT_TYPE_USER_H
 #define LLVM_ABSTRACT_TYPE_USER_H
 
+#if !defined(LLVM_TYPE_H) && !defined(LLVM_VALUE_H)
+#error Do not include this file directly.  Include Type.h instead.
+#error Some versions of GCC (e.g. 3.4 and 4.1) can not handle the inlined method
+#error PATypeHolder::dropRef() correctly otherwise.
+#endif
+
 // This is the "master" include for <cassert> Whether this file needs it or not,
 // it must always include <cassert> for the files which include
 // llvm/AbstractTypeUser.h
@@ -42,6 +34,23 @@ namespace llvm {
 class Type;
 class DerivedType;
 
+/// The AbstractTypeUser class is an interface to be implemented by classes who
+/// could possibly use an abstract type.  Abstract types are denoted by the
+/// isAbstract flag set to true in the Type class.  These are classes that
+/// contain an Opaque type in their structure somewhere.
+///
+/// Classes must implement this interface so that they may be notified when an
+/// abstract type is resolved.  Abstract types may be resolved into more 
+/// concrete types through: linking, parsing, and bitcode reading.  When this 
+/// happens, all of the users of the type must be updated to reference the new,
+/// more concrete type.  They are notified through the AbstractTypeUser 
+/// interface.
+///
+/// In addition to this, AbstractTypeUsers must keep the use list of the
+/// potentially abstract type that they reference up-to-date.  To do this in a
+/// nice, transparent way, the PATypeHandle class is used to hold "Potentially
+/// Abstract Types", and keep the use list of the abstract types up-to-date.
+/// @brief LLVM Abstract Type User Representation
 class AbstractTypeUser {
 protected:
   virtual ~AbstractTypeUser();                        // Derive from me