Chris Lattner | cf3056d | 2003-10-13 03:32:08 +0000 | [diff] [blame] | 1 | //===-- TransformInternals.h - Shared functions for Transforms --*- C++ -*-===// |
John Criswell | 856ba76 | 2003-10-21 15:17:13 +0000 | [diff] [blame] | 2 | // |
| 3 | // The LLVM Compiler Infrastructure |
| 4 | // |
| 5 | // This file was developed by the LLVM research group and is distributed under |
| 6 | // the University of Illinois Open Source License. See LICENSE.TXT for details. |
| 7 | // |
| 8 | //===----------------------------------------------------------------------===// |
Chris Lattner | 59cd9f1 | 2001-11-04 23:24:06 +0000 | [diff] [blame] | 9 | // |
| 10 | // This header file declares shared functions used by the different components |
| 11 | // of the Transforms library. |
| 12 | // |
| 13 | //===----------------------------------------------------------------------===// |
| 14 | |
| 15 | #ifndef TRANSFORM_INTERNALS_H |
| 16 | #define TRANSFORM_INTERNALS_H |
| 17 | |
| 18 | #include "llvm/BasicBlock.h" |
| 19 | #include "llvm/Target/TargetData.h" |
Chris Lattner | c0b90e7 | 2001-11-08 20:19:56 +0000 | [diff] [blame] | 20 | #include "llvm/DerivedTypes.h" |
Chris Lattner | 31bcdb8 | 2002-04-28 19:55:58 +0000 | [diff] [blame] | 21 | #include "llvm/Constants.h" |
Chris Lattner | 59cd9f1 | 2001-11-04 23:24:06 +0000 | [diff] [blame] | 22 | #include <map> |
Chris Lattner | e4f4d8c | 2001-11-05 18:30:53 +0000 | [diff] [blame] | 23 | #include <set> |
Chris Lattner | 59cd9f1 | 2001-11-04 23:24:06 +0000 | [diff] [blame] | 24 | |
Brian Gaeke | d0fde30 | 2003-11-11 22:41:34 +0000 | [diff] [blame] | 25 | namespace llvm { |
| 26 | |
Chris Lattner | 8e2e5f7 | 2002-09-16 18:32:33 +0000 | [diff] [blame] | 27 | static inline int64_t getConstantValue(const ConstantInt *CPI) { |
Chris Lattner | c07736a | 2003-07-23 15:22:26 +0000 | [diff] [blame] | 28 | return (int64_t)cast<ConstantInt>(CPI)->getRawValue(); |
Chris Lattner | 491b29f | 2001-11-26 17:00:13 +0000 | [diff] [blame] | 29 | } |
Chris Lattner | 59cd9f1 | 2001-11-04 23:24:06 +0000 | [diff] [blame] | 30 | |
| 31 | |
Chris Lattner | 491b29f | 2001-11-26 17:00:13 +0000 | [diff] [blame] | 32 | // getPointedToComposite - If the argument is a pointer type, and the pointed to |
| 33 | // value is a composite type, return the composite type, else return null. |
Chris Lattner | c0b90e7 | 2001-11-08 20:19:56 +0000 | [diff] [blame] | 34 | // |
Chris Lattner | 491b29f | 2001-11-26 17:00:13 +0000 | [diff] [blame] | 35 | static inline const CompositeType *getPointedToComposite(const Type *Ty) { |
Chris Lattner | c0b90e7 | 2001-11-08 20:19:56 +0000 | [diff] [blame] | 36 | const PointerType *PT = dyn_cast<PointerType>(Ty); |
Chris Lattner | 7a17675 | 2001-12-04 00:03:30 +0000 | [diff] [blame] | 37 | return PT ? dyn_cast<CompositeType>(PT->getElementType()) : 0; |
Chris Lattner | c0b90e7 | 2001-11-08 20:19:56 +0000 | [diff] [blame] | 38 | } |
| 39 | |
Misha Brukman | f117cc9 | 2003-05-20 18:45:36 +0000 | [diff] [blame] | 40 | // ConvertibleToGEP - This function returns true if the specified value V is |
Chris Lattner | 491b29f | 2001-11-26 17:00:13 +0000 | [diff] [blame] | 41 | // a valid index into a pointer of type Ty. If it is valid, Idx is filled in |
| 42 | // with the values that would be appropriate to make this a getelementptr |
| 43 | // instruction. The type returned is the root type that the GEP would point |
| 44 | // to if it were synthesized with this operands. |
| 45 | // |
| 46 | // If BI is nonnull, cast instructions are inserted as appropriate for the |
| 47 | // arguments of the getelementptr. |
| 48 | // |
Misha Brukman | f117cc9 | 2003-05-20 18:45:36 +0000 | [diff] [blame] | 49 | const Type *ConvertibleToGEP(const Type *Ty, Value *V, |
Chris Lattner | 697954c | 2002-01-20 22:54:45 +0000 | [diff] [blame] | 50 | std::vector<Value*> &Indices, |
Chris Lattner | 16125fb | 2003-04-24 18:25:27 +0000 | [diff] [blame] | 51 | const TargetData &TD, |
Chris Lattner | 491b29f | 2001-11-26 17:00:13 +0000 | [diff] [blame] | 52 | BasicBlock::iterator *BI = 0); |
| 53 | |
| 54 | |
Chris Lattner | b1b4262 | 2002-07-17 17:11:33 +0000 | [diff] [blame] | 55 | //===----------------------------------------------------------------------===// |
| 56 | // ValueHandle Class - Smart pointer that occupies a slot on the users USE list |
| 57 | // that prevents it from being destroyed. This "looks" like an Instruction |
| 58 | // with Opcode UserOp1. |
| 59 | // |
| 60 | class ValueMapCache; |
| 61 | class ValueHandle : public Instruction { |
| 62 | ValueMapCache &Cache; |
| 63 | public: |
| 64 | ValueHandle(ValueMapCache &VMC, Value *V); |
| 65 | ValueHandle(const ValueHandle &); |
| 66 | ~ValueHandle(); |
| 67 | |
| 68 | virtual Instruction *clone() const { abort(); return 0; } |
| 69 | |
| 70 | virtual const char *getOpcodeName() const { |
| 71 | return "ValueHandle"; |
| 72 | } |
| 73 | |
| 74 | inline bool operator<(const ValueHandle &VH) const { |
| 75 | return getOperand(0) < VH.getOperand(0); |
| 76 | } |
| 77 | |
| 78 | // Methods for support type inquiry through isa, cast, and dyn_cast: |
| 79 | static inline bool classof(const ValueHandle *) { return true; } |
| 80 | static inline bool classof(const Instruction *I) { |
| 81 | return (I->getOpcode() == Instruction::UserOp1); |
| 82 | } |
| 83 | static inline bool classof(const Value *V) { |
| 84 | return isa<Instruction>(V) && classof(cast<Instruction>(V)); |
| 85 | } |
| 86 | }; |
| 87 | |
| 88 | |
Chris Lattner | 59cd9f1 | 2001-11-04 23:24:06 +0000 | [diff] [blame] | 89 | // ------------- Expression Conversion --------------------- |
| 90 | |
Chris Lattner | b1b4262 | 2002-07-17 17:11:33 +0000 | [diff] [blame] | 91 | typedef std::map<const Value*, const Type*> ValueTypeCache; |
Chris Lattner | e4f4d8c | 2001-11-05 18:30:53 +0000 | [diff] [blame] | 92 | |
| 93 | struct ValueMapCache { |
| 94 | // Operands mapped - Contains an entry if the first value (the user) has had |
| 95 | // the second value (the operand) mapped already. |
| 96 | // |
Chris Lattner | 697954c | 2002-01-20 22:54:45 +0000 | [diff] [blame] | 97 | std::set<const User*> OperandsMapped; |
Chris Lattner | e4f4d8c | 2001-11-05 18:30:53 +0000 | [diff] [blame] | 98 | |
| 99 | // Expression Map - Contains an entry from the old value to the new value of |
| 100 | // an expression that has been converted over. |
| 101 | // |
Chris Lattner | 697954c | 2002-01-20 22:54:45 +0000 | [diff] [blame] | 102 | std::map<const Value *, Value *> ExprMap; |
| 103 | typedef std::map<const Value *, Value *> ExprMapTy; |
Chris Lattner | b1b4262 | 2002-07-17 17:11:33 +0000 | [diff] [blame] | 104 | |
| 105 | // Cast Map - Cast instructions can have their source and destination values |
Misha Brukman | ef6a6a6 | 2003-08-21 22:14:26 +0000 | [diff] [blame] | 106 | // changed independently for each part. Because of this, our old naive |
Chris Lattner | b1b4262 | 2002-07-17 17:11:33 +0000 | [diff] [blame] | 107 | // implementation would create a TWO new cast instructions, which would cause |
| 108 | // all kinds of problems. Here we keep track of the newly allocated casts, so |
| 109 | // that we only create one for a particular instruction. |
| 110 | // |
| 111 | std::set<ValueHandle> NewCasts; |
Chris Lattner | e4f4d8c | 2001-11-05 18:30:53 +0000 | [diff] [blame] | 112 | }; |
Chris Lattner | 59cd9f1 | 2001-11-04 23:24:06 +0000 | [diff] [blame] | 113 | |
Chris Lattner | c0b90e7 | 2001-11-08 20:19:56 +0000 | [diff] [blame] | 114 | |
Misha Brukman | f117cc9 | 2003-05-20 18:45:36 +0000 | [diff] [blame] | 115 | bool ExpressionConvertibleToType(Value *V, const Type *Ty, ValueTypeCache &Map, |
Chris Lattner | 16125fb | 2003-04-24 18:25:27 +0000 | [diff] [blame] | 116 | const TargetData &TD); |
| 117 | Value *ConvertExpressionToType(Value *V, const Type *Ty, ValueMapCache &VMC, |
| 118 | const TargetData &TD); |
Chris Lattner | c0b90e7 | 2001-11-08 20:19:56 +0000 | [diff] [blame] | 119 | |
Misha Brukman | f117cc9 | 2003-05-20 18:45:36 +0000 | [diff] [blame] | 120 | // ValueConvertibleToType - Return true if it is possible |
| 121 | bool ValueConvertibleToType(Value *V, const Type *Ty, |
Chris Lattner | 16125fb | 2003-04-24 18:25:27 +0000 | [diff] [blame] | 122 | ValueTypeCache &ConvertedTypes, |
| 123 | const TargetData &TD); |
Chris Lattner | 59cd9f1 | 2001-11-04 23:24:06 +0000 | [diff] [blame] | 124 | |
Chris Lattner | 16125fb | 2003-04-24 18:25:27 +0000 | [diff] [blame] | 125 | void ConvertValueToNewType(Value *V, Value *NewVal, ValueMapCache &VMC, |
| 126 | const TargetData &TD); |
Chris Lattner | 59cd9f1 | 2001-11-04 23:24:06 +0000 | [diff] [blame] | 127 | |
| 128 | |
Chris Lattner | c0b90e7 | 2001-11-08 20:19:56 +0000 | [diff] [blame] | 129 | // getStructOffsetType - Return a vector of offsets that are to be used to index |
| 130 | // into the specified struct type to get as close as possible to index as we |
| 131 | // can. Note that it is possible that we cannot get exactly to Offset, in which |
| 132 | // case we update offset to be the offset we actually obtained. The resultant |
| 133 | // leaf type is returned. |
| 134 | // |
| 135 | // If StopEarly is set to true (the default), the first object with the |
| 136 | // specified type is returned, even if it is a struct type itself. In this |
| 137 | // case, this routine will not drill down to the leaf type. Set StopEarly to |
| 138 | // false if you want a leaf |
| 139 | // |
| 140 | const Type *getStructOffsetType(const Type *Ty, unsigned &Offset, |
Chris Lattner | 697954c | 2002-01-20 22:54:45 +0000 | [diff] [blame] | 141 | std::vector<Value*> &Offsets, |
Chris Lattner | 16125fb | 2003-04-24 18:25:27 +0000 | [diff] [blame] | 142 | const TargetData &TD, bool StopEarly = true); |
Chris Lattner | c0b90e7 | 2001-11-08 20:19:56 +0000 | [diff] [blame] | 143 | |
Brian Gaeke | d0fde30 | 2003-11-11 22:41:34 +0000 | [diff] [blame] | 144 | } // End llvm namespace |
| 145 | |
Chris Lattner | 59cd9f1 | 2001-11-04 23:24:06 +0000 | [diff] [blame] | 146 | #endif |