X-Git-Url: http://demsky.eecs.uci.edu/git/?a=blobdiff_plain;f=lib%2FTransforms%2FTransformInternals.h;h=3b80146a2780c14b28215ca642bd3d8a04952ab6;hb=2636c1be17c384993c25e9fe1e61a76cee157aa1;hp=8edeffc82e199f0befa5a1dff4ec9ef3d7f765d6;hpb=491b29f2471410cf7890698c3ad94118a32a0656;p=oota-llvm.git diff --git a/lib/Transforms/TransformInternals.h b/lib/Transforms/TransformInternals.h index 8edeffc82e1..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,59 +16,28 @@ #define TRANSFORM_INTERNALS_H #include "llvm/BasicBlock.h" -#include "llvm/Instruction.h" #include "llvm/Target/TargetData.h" #include "llvm/DerivedTypes.h" -#include "llvm/ConstPoolVals.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 int getConstantValue(const ConstPoolInt *CPI) { - if (const ConstPoolSInt *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(); } -// 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(); -} - // 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 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. -// -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); - - -// 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 @@ -70,48 +46,23 @@ void ReplaceInstWithInst(BasicBlock::InstListType &BIL, // If BI is nonnull, cast instructions are inserted as appropriate for the // arguments of the getelementptr. // -const Type *ConvertableToGEP(const Type *Ty, Value *V, vector &Indices, +const Type *ConvertibleToGEP(const Type *Ty, Value *V, + std::vector &Indices, + const TargetData &TD, BasicBlock::iterator *BI = 0); -// ------------- 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); - -// 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; } @@ -120,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) { @@ -130,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 @@ -142,7 +138,9 @@ public: // false if you want a leaf // const Type *getStructOffsetType(const Type *Ty, unsigned &Offset, - vector &Offsets, - bool StopEarly = true); + std::vector &Offsets, + const TargetData &TD, bool StopEarly = true); + +} // End llvm namespace #endif