1 //===-- TransformInternals.h - Shared functions for Transforms ---*- C++ -*--=//
3 // This header file declares shared functions used by the different components
4 // of the Transforms library.
6 //===----------------------------------------------------------------------===//
8 #ifndef TRANSFORM_INTERNALS_H
9 #define TRANSFORM_INTERNALS_H
11 #include "llvm/BasicBlock.h"
12 #include "llvm/Instruction.h"
13 #include "llvm/Target/TargetData.h"
17 // TargetData Hack: Eventually we will have annotations given to us by the
18 // backend so that we know stuff about type size and alignments. For now
19 // though, just use this, because it happens to match the model that GCC uses.
21 // FIXME: This should use annotations
23 extern const TargetData TD;
25 // losslessCastableTypes - Return true if the types are bitwise equivalent.
26 // This predicate returns true if it is possible to cast from one type to
27 // another without gaining or losing precision, or altering the bits in any way.
29 bool losslessCastableTypes(const Type *T1, const Type *T2);
32 // isFirstClassType - Return true if a value of the specified type can be held
35 static inline bool isFirstClassType(const Type *Ty) {
36 return Ty->isPrimitiveType() || Ty->isPointerType();
40 // ReplaceInstWithValue - Replace all uses of an instruction (specified by BI)
41 // with a value, then remove and delete the original instruction.
43 void ReplaceInstWithValue(BasicBlock::InstListType &BIL,
44 BasicBlock::iterator &BI, Value *V);
46 // ReplaceInstWithInst - Replace the instruction specified by BI with the
47 // instruction specified by I. The original instruction is deleted and BI is
48 // updated to point to the new instruction.
50 void ReplaceInstWithInst(BasicBlock::InstListType &BIL,
51 BasicBlock::iterator &BI, Instruction *I);
54 // ------------- Expression Conversion ---------------------
56 typedef map<const Value*, const Type*> ValueTypeCache;
58 struct ValueMapCache {
59 // Operands mapped - Contains an entry if the first value (the user) has had
60 // the second value (the operand) mapped already.
62 set<const User*> OperandsMapped;
64 // Expression Map - Contains an entry from the old value to the new value of
65 // an expression that has been converted over.
67 map<const Value *, Value *> ExprMap;
68 typedef map<const Value *, Value *> ExprMapTy;
71 // RetValConvertableToType - Return true if it is possible
72 bool RetValConvertableToType(Value *V, const Type *Ty,
73 ValueTypeCache &ConvertedTypes);
75 void ConvertUsersType(Value *V, Value *NewVal, ValueMapCache &VMC);
78 //===----------------------------------------------------------------------===//
79 // ValueHandle Class - Smart pointer that occupies a slot on the users USE list
80 // that prevents it from being destroyed. This "looks" like an Instruction
81 // with Opcode UserOp1.
83 class ValueHandle : public Instruction {
84 ValueHandle(const ValueHandle &); // DO NOT IMPLEMENT
86 ValueHandle(Value *V);
89 virtual Instruction *clone() const { abort(); return 0; }
91 virtual const char *getOpcodeName() const {
95 // Methods for support type inquiry through isa, cast, and dyn_cast:
96 static inline bool classof(const ValueHandle *) { return true; }
97 static inline bool classof(const Instruction *I) {
98 return (I->getOpcode() == Instruction::UserOp1);
100 static inline bool classof(const Value *V) {
101 return isa<Instruction>(V) && classof(cast<Instruction>(V));