X-Git-Url: http://demsky.eecs.uci.edu/git/?a=blobdiff_plain;f=lib%2FTransforms%2FTransformInternals.h;h=867dd5d4abea7a293017d215690bc0c42f474cef;hb=eb0456c8fd60e6c2ef844d8696baa39d5d55f082;hp=ea427327d4a318350efd73a24bc64acb56ed9128;hpb=c0b90e7dd575ba59035334397722d677231a8f13;p=oota-llvm.git diff --git a/lib/Transforms/TransformInternals.h b/lib/Transforms/TransformInternals.h index ea427327d4a..867dd5d4abe 100644 --- a/lib/Transforms/TransformInternals.h +++ b/lib/Transforms/TransformInternals.h @@ -9,9 +9,9 @@ #define TRANSFORM_INTERNALS_H #include "llvm/BasicBlock.h" -#include "llvm/Instruction.h" #include "llvm/Target/TargetData.h" #include "llvm/DerivedTypes.h" +#include "llvm/Constants.h" #include #include @@ -23,69 +23,33 @@ // extern const TargetData TD; -// losslessCastableTypes - Return true if the types are bitwise equivalent. -// This predicate returns true if it is possible to cast from one type to -// another without gaining or losing precision, or altering the bits in any way. -// -bool losslessCastableTypes(const Type *T1, const Type *T2); - - -// isFirstClassType - Return true if a value of the specified type can be held -// in a register. -// -static inline bool isFirstClassType(const Type *Ty) { - return Ty->isPrimitiveType() || Ty->isPointerType(); +static inline int64_t getConstantValue(const ConstantInt *CPI) { + if (const ConstantSInt *CSI = dyn_cast(CPI)) + return CSI->getValue(); + return (int64_t)cast(CPI)->getValue(); } -// getPointedToStruct - If the argument is a pointer type, and the pointed to -// value is a struct type, return the struct type, else return null. + +// getPointedToComposite - If the argument is a pointer type, and the pointed to +// value is a composite type, return the composite type, else return null. // -static inline const StructType *getPointedToStruct(const Type *Ty) { +static inline const CompositeType *getPointedToComposite(const Type *Ty) { const PointerType *PT = dyn_cast(Ty); - return PT ? dyn_cast(PT->getValueType()) : 0; + return PT ? dyn_cast(PT->getElementType()) : 0; } - -// ReplaceInstWithValue - Replace all uses of an instruction (specified by BI) -// with a value, then remove and delete the original instruction. +// ConvertableToGEP - This function returns true if the specified value V is +// a valid index into a pointer of type Ty. If it is valid, Idx is filled in +// with the values that would be appropriate to make this a getelementptr +// instruction. The type returned is the root type that the GEP would point +// to if it were synthesized with this operands. // -void ReplaceInstWithValue(BasicBlock::InstListType &BIL, - BasicBlock::iterator &BI, Value *V); - -// ReplaceInstWithInst - Replace the instruction specified by BI with the -// instruction specified by I. The original instruction is deleted and BI is -// updated to point to the new instruction. +// If BI is nonnull, cast instructions are inserted as appropriate for the +// arguments of the getelementptr. // -void ReplaceInstWithInst(BasicBlock::InstListType &BIL, - BasicBlock::iterator &BI, Instruction *I); - - -// ------------- Expression Conversion --------------------- - -typedef map ValueTypeCache; - -struct ValueMapCache { - // Operands mapped - Contains an entry if the first value (the user) has had - // the second value (the operand) mapped already. - // - set OperandsMapped; - - // Expression Map - Contains an entry from the old value to the new value of - // an expression that has been converted over. - // - map ExprMap; - typedef map ExprMapTy; -}; - - -bool ExpressionConvertableToType(Value *V, const Type *Ty, ValueTypeCache &Map); -Value *ConvertExpressionToType(Value *V, const Type *Ty, ValueMapCache &VMC); - -// RetValConvertableToType - Return true if it is possible -bool RetValConvertableToType(Value *V, const Type *Ty, - ValueTypeCache &ConvertedTypes); - -void ConvertUsersType(Value *V, Value *NewVal, ValueMapCache &VMC); +const Type *ConvertableToGEP(const Type *Ty, Value *V, + std::vector &Indices, + BasicBlock::iterator *BI = 0); //===----------------------------------------------------------------------===// @@ -93,10 +57,12 @@ void ConvertUsersType(Value *V, Value *NewVal, ValueMapCache &VMC); // that prevents it from being destroyed. This "looks" like an Instruction // with Opcode UserOp1. // +class ValueMapCache; class ValueHandle : public Instruction { - ValueHandle(const ValueHandle &); // DO NOT IMPLEMENT + ValueMapCache &Cache; public: - ValueHandle(Value *V); + ValueHandle(ValueMapCache &VMC, Value *V); + ValueHandle(const ValueHandle &); ~ValueHandle(); virtual Instruction *clone() const { abort(); return 0; } @@ -105,6 +71,10 @@ public: return "ValueHandle"; } + inline bool operator<(const ValueHandle &VH) const { + return getOperand(0) < VH.getOperand(0); + } + // Methods for support type inquiry through isa, cast, and dyn_cast: static inline bool classof(const ValueHandle *) { return true; } static inline bool classof(const Instruction *I) { @@ -115,6 +85,43 @@ public: } }; + +// ------------- Expression Conversion --------------------- + +typedef std::map ValueTypeCache; + +struct ValueMapCache { + // Operands mapped - Contains an entry if the first value (the user) has had + // the second value (the operand) mapped already. + // + std::set OperandsMapped; + + // Expression Map - Contains an entry from the old value to the new value of + // an expression that has been converted over. + // + std::map ExprMap; + typedef std::map ExprMapTy; + + // Cast Map - Cast instructions can have their source and destination values + // changed independantly for each part. Because of this, our old naive + // implementation would create a TWO new cast instructions, which would cause + // all kinds of problems. Here we keep track of the newly allocated casts, so + // that we only create one for a particular instruction. + // + std::set NewCasts; +}; + + +bool ExpressionConvertableToType(Value *V, const Type *Ty, ValueTypeCache &Map); +Value *ConvertExpressionToType(Value *V, const Type *Ty, ValueMapCache &VMC); + +// ValueConvertableToType - Return true if it is possible +bool ValueConvertableToType(Value *V, const Type *Ty, + ValueTypeCache &ConvertedTypes); + +void ConvertValueToNewType(Value *V, Value *NewVal, ValueMapCache &VMC); + + // getStructOffsetType - Return a vector of offsets that are to be used to index // into the specified struct type to get as close as possible to index as we // can. Note that it is possible that we cannot get exactly to Offset, in which @@ -127,7 +134,7 @@ public: // false if you want a leaf // const Type *getStructOffsetType(const Type *Ty, unsigned &Offset, - vector &Offsets, + std::vector &Offsets, bool StopEarly = true); #endif