From 1462aa78c79cdfbbacca822be14a22a79f63f22b Mon Sep 17 00:00:00 2001 From: Chris Lattner Date: Sat, 29 Oct 2005 04:40:23 +0000 Subject: [PATCH] Now that instcombine does this xform, remove it from the -raise pass git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@24082 91177308-0d34-0410-b5e6-96231b3b80d8 --- lib/Transforms/ExprTypeConvert.cpp | 120 ----------------------------- 1 file changed, 120 deletions(-) diff --git a/lib/Transforms/ExprTypeConvert.cpp b/lib/Transforms/ExprTypeConvert.cpp index 9a7f18871b0..7ed0d42f140 100644 --- a/lib/Transforms/ExprTypeConvert.cpp +++ b/lib/Transforms/ExprTypeConvert.cpp @@ -16,7 +16,6 @@ #include "TransformInternals.h" #include "llvm/Constants.h" #include "llvm/Instructions.h" -#include "llvm/Analysis/Expressions.h" #include "llvm/ADT/STLExtras.h" #include "llvm/Support/Debug.h" #include @@ -29,115 +28,6 @@ static bool OperandConvertibleToType(User *U, Value *V, const Type *Ty, static void ConvertOperandToType(User *U, Value *OldVal, Value *NewVal, ValueMapCache &VMC, const TargetData &TD); -// Peephole Malloc instructions: we take a look at the use chain of the -// malloc instruction, and try to find out if the following conditions hold: -// 1. The malloc is of the form: 'malloc [sbyte], uint ' -// 2. The only users of the malloc are cast & add instructions -// 3. Of the cast instructions, there is only one destination pointer type -// [RTy] where the size of the pointed to object is equal to the number -// of bytes allocated. -// -// If these conditions hold, we convert the malloc to allocate an [RTy] -// element. TODO: This comment is out of date WRT arrays -// -static bool MallocConvertibleToType(MallocInst *MI, const Type *Ty, - ValueTypeCache &CTMap, - const TargetData &TD) { - if (!isa(Ty)) return false; // Malloc always returns pointers - - // Deal with the type to allocate, not the pointer type... - Ty = cast(Ty)->getElementType(); - if (!Ty->isSized() || !MI->getType()->getElementType()->isSized()) - return false; // Can only alloc something with a size - - // Analyze the number of bytes allocated... - ExprType Expr = ClassifyExpr(MI->getArraySize()); - - // Get information about the base datatype being allocated, before & after - uint64_t ReqTypeSize = TD.getTypeSize(Ty); - if (ReqTypeSize == 0) return false; - uint64_t OldTypeSize = TD.getTypeSize(MI->getType()->getElementType()); - - // Must have a scale or offset to analyze it... - if (!Expr.Offset && !Expr.Scale && OldTypeSize == 1) return false; - - // Get the offset and scale of the allocation... - int64_t OffsetVal = Expr.Offset ? getConstantValue(Expr.Offset) : 0; - int64_t ScaleVal = Expr.Scale ? getConstantValue(Expr.Scale) :(Expr.Var != 0); - - // The old type might not be of unit size, take old size into consideration - // here... - uint64_t Offset = OffsetVal * OldTypeSize; - uint64_t Scale = ScaleVal * OldTypeSize; - - // In order to be successful, both the scale and the offset must be a multiple - // of the requested data type's size. - // - if (Offset/ReqTypeSize*ReqTypeSize != Offset || - Scale/ReqTypeSize*ReqTypeSize != Scale) - return false; // Nope. - - return true; -} - -static Instruction *ConvertMallocToType(MallocInst *MI, const Type *Ty, - const std::string &Name, - ValueMapCache &VMC, - const TargetData &TD){ - BasicBlock *BB = MI->getParent(); - BasicBlock::iterator It = BB->end(); - - // Analyze the number of bytes allocated... - ExprType Expr = ClassifyExpr(MI->getArraySize()); - - const PointerType *AllocTy = cast(Ty); - const Type *ElType = AllocTy->getElementType(); - - uint64_t DataSize = TD.getTypeSize(ElType); - uint64_t OldTypeSize = TD.getTypeSize(MI->getType()->getElementType()); - - // Get the offset and scale coefficients that we are allocating... - int64_t OffsetVal = (Expr.Offset ? getConstantValue(Expr.Offset) : 0); - int64_t ScaleVal = Expr.Scale ? getConstantValue(Expr.Scale) : (Expr.Var !=0); - - // The old type might not be of unit size, take old size into consideration - // here... - unsigned Offset = OffsetVal * OldTypeSize / DataSize; - unsigned Scale = ScaleVal * OldTypeSize / DataSize; - - // Locate the malloc instruction, because we may be inserting instructions - It = MI; - - // If we have a scale, apply it first... - if (Expr.Var) { - // Expr.Var is not necessarily unsigned right now, insert a cast now. - if (Expr.Var->getType() != Type::UIntTy) - Expr.Var = new CastInst(Expr.Var, Type::UIntTy, - Expr.Var->getName()+"-uint", It); - - if (Scale != 1) - Expr.Var = BinaryOperator::create(Instruction::Mul, Expr.Var, - ConstantUInt::get(Type::UIntTy, Scale), - Expr.Var->getName()+"-scl", It); - - } else { - // If we are not scaling anything, just make the offset be the "var"... - Expr.Var = ConstantUInt::get(Type::UIntTy, Offset); - Offset = 0; Scale = 1; - } - - // If we have an offset now, add it in... - if (Offset != 0) { - assert(Expr.Var && "Var must be nonnull by now!"); - Expr.Var = BinaryOperator::create(Instruction::Add, Expr.Var, - ConstantUInt::get(Type::UIntTy, Offset), - Expr.Var->getName()+"-off", It); - } - - assert(AllocTy == Ty); - return new MallocInst(AllocTy->getElementType(), Expr.Var, Name); -} - // ExpressionConvertibleToType - Return true if it is possible bool llvm::ExpressionConvertibleToType(Value *V, const Type *Ty, @@ -213,11 +103,6 @@ bool llvm::ExpressionConvertibleToType(Value *V, const Type *Ty, break; } - case Instruction::Malloc: - if (!MallocConvertibleToType(cast(I), Ty, CTMap, TD)) - return false; - break; - case Instruction::GetElementPtr: { // GetElementPtr's are directly convertible to a pointer type if they have // a number of zeros at the end. Because removing these values does not @@ -396,11 +281,6 @@ Value *llvm::ConvertExpressionToType(Value *V, const Type *Ty, break; } - case Instruction::Malloc: { - Res = ConvertMallocToType(cast(I), Ty, Name, VMC, TD); - break; - } - case Instruction::GetElementPtr: { // GetElementPtr's are directly convertible to a pointer type if they have // a number of zeros at the end. Because removing these values does not