#include "llvm/Support/DataTypes.h"
#include "llvm/Support/Streams.h"
#include "llvm/ADT/GraphTraits.h"
-#include "llvm/ADT/iterator"
+#include "llvm/ADT/iterator.h"
#include <string>
#include <vector>
inline bool isPrimitiveType() const { return ID <= LastPrimitiveTyID; }
inline bool isDerivedType() const { return ID >= FirstDerivedTyID; }
- /// isFirstClassType - Return true if the value is holdable in a register.
+ /// isFirstClassType - Return true if the type is "first class", meaning it
+ /// is a valid type for a Value.
///
inline bool isFirstClassType() const {
+ // There are more first-class kinds than non-first-class kinds, so a
+ // negative test is simpler than a positive one.
+ return ID != FunctionTyID && ID != VoidTyID && ID != OpaqueTyID;
+ }
+
+ /// isSingleValueType - Return true if the type is a valid type for a
+ /// virtual register in codegen. This includes all first-class types
+ /// except struct and array types.
+ ///
+ inline bool isSingleValueType() const {
return (ID != VoidTyID && ID <= LastPrimitiveTyID) ||
ID == IntegerTyID || ID == PointerTyID || ID == VectorTyID;
}
+ /// isAggregateType - Return true if the type is an aggregate type. This
+ /// means it is valid as the first operand of an insertvalue or
+ /// extractvalue instruction. This includes struct and array types, but
+ /// does not include vector types.
+ ///
+ inline bool isAggregateType() const {
+ return ID == StructTyID || ID == ArrayTyID;
+ }
+
/// isSized - Return true if it makes sense to take the size of this type. To
/// get the actual size for a particular target, it is reasonable to use the
/// TargetData subsystem to do this.
// Define inline methods for PATypeHolder.
+/// get - This implements the forwarding part of the union-find algorithm for
+/// abstract types. Before every access to the Type*, we check to see if the
+/// type we are pointing to is forwarding to a new type. If so, we drop our
+/// reference to the type.
+///
+inline Type* PATypeHolder::get() const {
+ const Type *NewTy = Ty->getForwardedType();
+ if (!NewTy) return const_cast<Type*>(Ty);
+ return *const_cast<PATypeHolder*>(this) = NewTy;
+}
+
inline void PATypeHolder::addRef() {
assert(Ty && "Type Holder has a null type!");
if (Ty->isAbstract())