From e167af30239bdcd3ec0ffbed1f4692b4d9d07228 Mon Sep 17 00:00:00 2001 From: Vladimir Prus Date: Tue, 30 May 2006 15:49:30 +0000 Subject: [PATCH] Make doc comment visible in doxygen output. Clarify Type construction. git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@28555 91177308-0d34-0410-b5e6-96231b3b80d8 --- include/llvm/Type.h | 50 +++++++++++++++++++++++---------------------- 1 file changed, 26 insertions(+), 24 deletions(-) diff --git a/include/llvm/Type.h b/include/llvm/Type.h index 34da2e7c8e1..3daafa6cac4 100644 --- a/include/llvm/Type.h +++ b/include/llvm/Type.h @@ -6,30 +6,7 @@ // the University of Illinois Open Source License. See LICENSE.TXT for details. // //===----------------------------------------------------------------------===// -// -// This file contains the declaration of the Type class. For more "Type" type -// stuff, look in DerivedTypes.h. -// -// Note that instances of the Type class are immutable: once they are created, -// they are never changed. Also note that only one instance of a particular -// type is ever created. Thus seeing if two types are equal is a matter of -// doing a trivial pointer comparison. -// -// Types, once allocated, are never free'd, unless they are an abstract type -// that is resolved to a more concrete type. -// -// Opaque types are simple derived types with no state. There may be many -// different Opaque type objects floating around, but two are only considered -// identical if they are pointer equals of each other. This allows us to have -// two opaque types that end up resolving to different concrete types later. -// -// Opaque types are also kinda weird and scary and different because they have -// to keep a list of uses of the type. When, through linking, parsing, or -// bytecode reading, they become resolved, they need to find and update all -// users of the unknown type, causing them to reference a new, more concrete -// type. Opaque types are deleted when their use list dwindles to zero users. -// -//===----------------------------------------------------------------------===// + #ifndef LLVM_TYPE_H #define LLVM_TYPE_H @@ -53,6 +30,31 @@ class StructType; class PackedType; class TypeMapBase; +/// This file contains the declaration of the Type class. For more "Type" type +/// stuff, look in DerivedTypes.h. +/// +/// The instances of the Type class are immutable: once they are created, +/// they are never changed. Also note that only one instance of a particular +/// type is ever created. Thus seeing if two types are equal is a matter of +/// doing a trivial pointer comparison. To enforce that no two equal instances +/// are created, Type instances can only be created via static factory methods +/// in class Type and in derived classes. +/// +/// Once allocated, Types are never free'd, unless they are an abstract type +/// that is resolved to a more concrete type. +/// +/// Opaque types are simple derived types with no state. There may be many +/// different Opaque type objects floating around, but two are only considered +/// identical if they are pointer equals of each other. This allows us to have +/// two opaque types that end up resolving to different concrete types later. +/// +/// Opaque types are also kinda weird and scary and different because they have +/// to keep a list of uses of the type. When, through linking, parsing, or +/// bytecode reading, they become resolved, they need to find and update all +/// users of the unknown type, causing them to reference a new, more concrete +/// type. Opaque types are deleted when their use list dwindles to zero users. +/// +/// @brief Root of type hierarchy class Type : public AbstractTypeUser { public: ///===-------------------------------------------------------------------===//