X-Git-Url: http://demsky.eecs.uci.edu/git/?a=blobdiff_plain;f=lib%2FTransforms%2FTransformInternals.h;h=3b80146a2780c14b28215ca642bd3d8a04952ab6;hb=2636c1be17c384993c25e9fe1e61a76cee157aa1;hp=30e3990df48bc65cd2c523d94d9f6bbc0b1be758;hpb=f78642bc06164b8d3be18c3a6ccda2204f7ffe1d;p=oota-llvm.git diff --git a/lib/Transforms/TransformInternals.h b/lib/Transforms/TransformInternals.h index 30e3990df48..3b80146a278 100644 --- a/lib/Transforms/TransformInternals.h +++ b/lib/Transforms/TransformInternals.h @@ -1,4 +1,11 @@ -//===-- TransformInternals.h - Shared functions for Transforms ---*- C++ -*--=// +//===-- TransformInternals.h - Shared functions for Transforms --*- C++ -*-===// +// +// 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 header file declares shared functions used by the different components // of the Transforms library. @@ -9,25 +16,16 @@ #define TRANSFORM_INTERNALS_H #include "llvm/BasicBlock.h" -#include "llvm/Instruction.h" #include "llvm/Target/TargetData.h" #include "llvm/DerivedTypes.h" -#include "llvm/ConstantVals.h" +#include "llvm/Constants.h" #include #include -// TargetData Hack: Eventually we will have annotations given to us by the -// backend so that we know stuff about type size and alignments. For now -// though, just use this, because it happens to match the model that GCC uses. -// -// FIXME: This should use annotations -// -extern const TargetData TD; +namespace llvm { -static inline int getConstantValue(const ConstantInt *CPI) { - if (const ConstantSInt *CSI = dyn_cast(CPI)) - return CSI->getValue(); - return cast(CPI)->getValue(); +static inline int64_t getConstantValue(const ConstantInt *CPI) { + return (int64_t)cast(CPI)->getRawValue(); } @@ -39,31 +37,7 @@ static inline const CompositeType *getPointedToComposite(const Type *Ty) { 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. -// -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. -// -void ReplaceInstWithInst(BasicBlock::InstListType &BIL, - BasicBlock::iterator &BI, Instruction *I); - -void ReplaceInstWithInst(Instruction *From, Instruction *To); - -// InsertInstBeforeInst - Insert 'NewInst' into the basic block that 'Existing' -// is already in, and put it right before 'Existing'. This instruction should -// only be used when there is no iterator to Existing already around. The -// returned iterator points to the new instruction. -// -BasicBlock::iterator InsertInstBeforeInst(Instruction *NewInst, - Instruction *Existing); - -// ConvertableToGEP - This function returns true if the specified value V is +// ConvertibleToGEP - 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 @@ -72,49 +46,23 @@ BasicBlock::iterator InsertInstBeforeInst(Instruction *NewInst, // If BI is nonnull, cast instructions are inserted as appropriate for the // arguments of the getelementptr. // -const Type *ConvertableToGEP(const Type *Ty, Value *V, +const Type *ConvertibleToGEP(const Type *Ty, Value *V, std::vector &Indices, + const TargetData &TD, BasicBlock::iterator *BI = 0); -// ------------- 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; -}; - - -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); - - //===----------------------------------------------------------------------===// // ValueHandle Class - Smart pointer that occupies a slot on the users USE list // 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(ValueMapCache &VMC, Value *V); + ValueHandle(const ValueHandle &); ~ValueHandle(); virtual Instruction *clone() const { abort(); return 0; } @@ -123,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) { @@ -133,6 +85,47 @@ 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 independently 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 ExpressionConvertibleToType(Value *V, const Type *Ty, ValueTypeCache &Map, + const TargetData &TD); +Value *ConvertExpressionToType(Value *V, const Type *Ty, ValueMapCache &VMC, + const TargetData &TD); + +// ValueConvertibleToType - Return true if it is possible +bool ValueConvertibleToType(Value *V, const Type *Ty, + ValueTypeCache &ConvertedTypes, + const TargetData &TD); + +void ConvertValueToNewType(Value *V, Value *NewVal, ValueMapCache &VMC, + const TargetData &TD); + + // 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 @@ -146,6 +139,8 @@ public: // const Type *getStructOffsetType(const Type *Ty, unsigned &Offset, std::vector &Offsets, - bool StopEarly = true); + const TargetData &TD, bool StopEarly = true); + +} // End llvm namespace #endif