RPCSX/llvm
1
0
Fork 0
mirror of https://github.com/RPCSX/llvm.git synced 2025-02-11 23:38:05 +00:00
Code Issues Actions Packages Projects Releases Wiki Activity

Make doc comment visible in doxygen output. Clarify Type construction.

Browse Source 
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@28555 91177308-0d34-0410-b5e6-96231b3b80d8
This commit is contained in:
Vladimir Prus 2006-05-30 15:49:30 +00:00
parent 1a2a0cc5a3
commit e167af3023
1 changed files with 26 additions and 24 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

50
include/llvm/Type.h
View File

@ -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:
///===-------------------------------------------------------------------===//