//===----------------------------------------------------------------------===//
#include "TransformInternals.h"
-#include "llvm/Method.h"
#include "llvm/iOther.h"
#include "llvm/iPHINode.h"
#include "llvm/iMemory.h"
-#include "llvm/ConstantVals.h"
-#include "llvm/Transforms/Scalar/ConstantHandling.h"
-#include "llvm/Transforms/Scalar/DCE.h"
+#include "llvm/ConstantHandling.h"
#include "llvm/Analysis/Expressions.h"
#include "Support/STLExtras.h"
-#include <map>
#include <algorithm>
#include <iostream>
using std::cerr;
-#include "llvm/Assembly/Writer.h"
-
//#define DEBUG_EXPR_CONVERT 1
static bool OperandConvertableToType(User *U, Value *V, const Type *Ty,
//
static bool MallocConvertableToType(MallocInst *MI, const Type *Ty,
ValueTypeCache &CTMap) {
- if (!MI->isArrayAllocation() || // No array allocation?
- !isa<PointerType>(Ty)) return false; // Malloc always returns pointers
+ if (!isa<PointerType>(Ty)) return false; // Malloc always returns pointers
// Deal with the type to allocate, not the pointer type...
Ty = cast<PointerType>(Ty)->getElementType();
analysis::ExprType Expr = analysis::ClassifyExpression(MI->getArraySize());
// Get information about the base datatype being allocated, before & after
- unsigned ReqTypeSize = TD.getTypeSize(Ty);
+ int ReqTypeSize = TD.getTypeSize(Ty);
unsigned OldTypeSize = TD.getTypeSize(MI->getType()->getElementType());
// Must have a scale or offset to analyze it...
- if (!Expr.Offset && !Expr.Scale) return false;
+ if (!Expr.Offset && !Expr.Scale && OldTypeSize == 1) return false;
// Get the offset and scale of the allocation...
int OffsetVal = Expr.Offset ? getConstantValue(Expr.Offset) : 0;
int ScaleVal = Expr.Scale ? getConstantValue(Expr.Scale) : (Expr.Var ? 1 : 0);
- if (ScaleVal < 0 || OffsetVal < 0) {
- cerr << "malloc of a negative number???\n";
- return false;
- }
// The old type might not be of unit size, take old size into consideration
// here...
- unsigned Offset = (unsigned)OffsetVal * OldTypeSize;
- unsigned Scale = (unsigned)ScaleVal * OldTypeSize;
+ int Offset = OffsetVal * OldTypeSize;
+ int 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.
ValueHandle IHandle(VMC, I); // Prevent I from being removed!
- Constant *Dummy = Constant::getNullConstant(Ty);
+ Constant *Dummy = Constant::getNullValue(Ty);
switch (I->getOpcode()) {
case Instruction::Cast:
LoadInst *LI = cast<LoadInst>(I);
assert(!LI->hasIndices() || AllIndicesZero(LI));
- Res = new LoadInst(Constant::getNullConstant(PointerType::get(Ty)), Name);
+ Res = new LoadInst(Constant::getNullValue(PointerType::get(Ty)), Name);
VMC.ExprMap[I] = Res;
Res->setOperand(0, ConvertExpressionToType(LI->getPointerOperand(),
PointerType::get(Ty), VMC));
Indices, &It);
if (ElTy) {
assert(ElTy == PVTy && "Internal error, setup wrong!");
- Res = new GetElementPtrInst(Constant::getNullConstant(NewSrcTy),
+ Res = new GetElementPtrInst(Constant::getNullValue(NewSrcTy),
Indices, Name);
VMC.ExprMap[I] = Res;
Res->setOperand(0, ConvertExpressionToType(I->getOperand(0),
//
if (Res == 0) {
const PointerType *NewSrcTy = PointerType::get(PVTy);
- Res = new GetElementPtrInst(Constant::getNullConstant(NewSrcTy),
+ Res = new GetElementPtrInst(Constant::getNullValue(NewSrcTy),
GEP->copyIndices(), Name);
VMC.ExprMap[I] = Res;
Res->setOperand(0, ConvertExpressionToType(I->getOperand(0),
I->getType() == I->getOperand(0)->getType())
return false;
+ // Do not allow a 'cast ushort %V to uint' to have it's first operand be
+ // converted to a 'short' type. Doing so changes the way sign promotion
+ // happens, and breaks things. Only allow the cast to take place if the
+ // signedness doesn't change... or if the current cast is not a lossy
+ // conversion.
+ //
+ if (!I->getType()->isLosslesslyConvertableTo(I->getOperand(0)->getType()) &&
+ I->getOperand(0)->getType()->isSigned() != Ty->isSigned())
+ return false;
#if 1
// We also do not allow conversion of a cast that casts from a ptr to array
if (SI->hasIndices()) return false;
if (V == I->getOperand(0)) {
+ ValueTypeCache::iterator CTMI = CTMap.find(I->getOperand(1));
+ if (CTMI != CTMap.end()) { // Operand #1 is in the table already?
+ // If so, check to see if it's Ty*, or, more importantly, if it is a
+ // pointer to a structure where the first element is a Ty... this code
+ // is neccesary because we might be trying to change the source and
+ // destination type of the store (they might be related) and the dest
+ // pointer type might be a pointer to structure. Below we allow pointer
+ // to structures where the 0th element is compatible with the value,
+ // now we have to support the symmetrical part of this.
+ //
+ const Type *ElTy = cast<PointerType>(CTMI->second)->getElementType();
+
+ // Already a pointer to what we want? Trivially accept...
+ if (ElTy == Ty) return true;
+
+ // Tricky case now, if the destination is a pointer to structure,
+ // obviously the source is not allowed to be a structure (cannot copy
+ // a whole structure at a time), so the level raiser must be trying to
+ // store into the first field. Check for this and allow it now:
+ //
+ if (StructType *SElTy = dyn_cast<StructType>(ElTy)) {
+ unsigned Offset = 0;
+ std::vector<Value*> Indices;
+ ElTy = getStructOffsetType(ElTy, Offset, Indices, false);
+ assert(Offset == 0 && "Offset changed!");
+ if (ElTy == 0) // Element at offset zero in struct doesn't exist!
+ return false; // Can only happen for {}*
+
+ if (ElTy == Ty) // Looks like the 0th element of structure is
+ return true; // compatible! Accept now!
+
+ // Otherwise we know that we can't work, so just stop trying now.
+ return false;
+ }
+ }
+
// Can convert the store if we can convert the pointer operand to match
// the new value type...
return ExpressionConvertableToType(I->getOperand(1), PointerType::get(Ty),
const Type *ElTy = PT->getElementType();
assert(V == I->getOperand(1));
+ if (isa<StructType>(ElTy)) {
+ // We can change the destination pointer if we can store our first
+ // argument into the first element of the structure...
+ //
+ unsigned Offset = 0;
+ std::vector<Value*> Indices;
+ ElTy = getStructOffsetType(ElTy, Offset, Indices, false);
+ assert(Offset == 0 && "Offset changed!");
+ if (ElTy == 0) // Element at offset zero in struct doesn't exist!
+ return false; // Can only happen for {}*
+ }
+
// Must move the same amount of data...
if (TD.getTypeSize(ElTy) != TD.getTypeSize(I->getOperand(0)->getType()))
return false;
assert (OI != I->op_end() && "Not using value!");
unsigned OpNum = OI - I->op_begin();
- // Are we trying to change the method pointer value to a new type?
+ // Are we trying to change the function pointer value to a new type?
if (OpNum == 0) {
PointerType *PTy = dyn_cast<PointerType>(Ty);
if (PTy == 0) return false; // Can't convert to a non-pointer type...
- MethodType *MTy = dyn_cast_or_null<MethodType>(PTy->getElementType());
- if (MTy == 0) return false; // Can't convert to a non ptr to method...
+ FunctionType *MTy = dyn_cast<FunctionType>(PTy->getElementType());
+ if (MTy == 0) return false; // Can't convert to a non ptr to function...
- // Perform sanity checks to make sure that new method type has the
+ // Perform sanity checks to make sure that new function type has the
// correct number of arguments...
//
- unsigned NumArgs = I->getNumOperands()-1; // Don't include method ptr
+ unsigned NumArgs = I->getNumOperands()-1; // Don't include function ptr
// Cannot convert to a type that requires more fixed arguments than
// the call provides...
//
if (NumArgs < MTy->getParamTypes().size()) return false;
- // Unless this is a vararg method type, we cannot provide more arguments
+ // Unless this is a vararg function type, we cannot provide more arguments
// than are desired...
//
if (!MTy->isVarArg() && NumArgs > MTy->getParamTypes().size())
return false;
- // Okay, at this point, we know that the call and the method type match
+ // Okay, at this point, we know that the call and the function type match
// number of arguments. Now we see if we can convert the arguments
- // themselves.
+ // themselves. Note that we do not require operands to be convertable,
+ // we can insert casts if they are convertible but not compatible. The
+ // reason for this is that we prefer to have resolved functions but casted
+ // arguments if possible.
//
- const MethodType::ParamTypes &PTs = MTy->getParamTypes();
+ const FunctionType::ParamTypes &PTs = MTy->getParamTypes();
for (unsigned i = 0, NA = PTs.size(); i < NA; ++i)
if (!PTs[i]->isLosslesslyConvertableTo(I->getOperand(i+1)->getType()))
return false; // Operands must have compatible types!
}
const PointerType *MPtr = cast<PointerType>(I->getOperand(0)->getType());
- const MethodType *MTy = cast<MethodType>(MPtr->getElementType());
+ const FunctionType *MTy = cast<FunctionType>(MPtr->getElementType());
if (!MTy->isVarArg()) return false;
if ((OpNum-1) < MTy->getParamTypes().size())
return false; // It's not in the varargs section...
// If we get this far, we know the value is in the varargs section of the
- // method! We can convert if we don't reinterpret the value...
+ // function! We can convert if we don't reinterpret the value...
//
return Ty->isLosslesslyConvertableTo(V->getType());
}
const Type *NewTy = NewVal->getType();
Constant *Dummy = (NewTy != Type::VoidTy) ?
- Constant::getNullConstant(NewTy) : 0;
+ Constant::getNullValue(NewTy) : 0;
switch (I->getOpcode()) {
case Instruction::Cast:
case Instruction::Store: {
if (I->getOperand(0) == OldVal) { // Replace the source value
const PointerType *NewPT = PointerType::get(NewTy);
- Res = new StoreInst(NewVal, Constant::getNullConstant(NewPT));
+ Res = new StoreInst(NewVal, Constant::getNullValue(NewPT));
VMC.ExprMap[I] = Res;
Res->setOperand(1, ConvertExpressionToType(I->getOperand(1), NewPT, VMC));
} else { // Replace the source pointer
const Type *ValTy = cast<PointerType>(NewTy)->getElementType();
std::vector<Value*> Indices;
-#if 0
- Indices.push_back(ConstantUInt::get(Type::UIntTy, 0));
- while (ArrayType *AT = dyn_cast<ArrayType>(ValTy)) {
+
+ if (isa<StructType>(ValTy)) {
+ unsigned Offset = 0;
Indices.push_back(ConstantUInt::get(Type::UIntTy, 0));
- ValTy = AT->getElementType();
+ ValTy = getStructOffsetType(ValTy, Offset, Indices, false);
+ assert(Offset == 0 && ValTy);
}
-#endif
- Res = new StoreInst(Constant::getNullConstant(ValTy), NewVal, Indices);
+
+ Res = new StoreInst(Constant::getNullValue(ValTy), NewVal, Indices);
VMC.ExprMap[I] = Res;
Res->setOperand(0, ConvertExpressionToType(I->getOperand(0), ValTy, VMC));
}
Value *Meth = I->getOperand(0);
std::vector<Value*> Params(I->op_begin()+1, I->op_end());
- if (Meth == OldVal) { // Changing the method pointer?
+ if (Meth == OldVal) { // Changing the function pointer?
PointerType *NewPTy = cast<PointerType>(NewVal->getType());
- MethodType *NewTy = cast<MethodType>(NewPTy->getElementType());
- const MethodType::ParamTypes &PTs = NewTy->getParamTypes();
+ FunctionType *NewTy = cast<FunctionType>(NewPTy->getElementType());
+ const FunctionType::ParamTypes &PTs = NewTy->getParamTypes();
+
+ // Get an iterator to the call instruction so that we can insert casts for
+ // operands if needbe. Note that we do not require operands to be
+ // convertable, we can insert casts if they are convertible but not
+ // compatible. The reason for this is that we prefer to have resolved
+ // functions but casted arguments if possible.
+ //
+ BasicBlock::iterator It = find(BIL.begin(), BIL.end(), I);
// Convert over all of the call operands to their new types... but only
// convert over the part that is not in the vararg section of the call.
//
for (unsigned i = 0; i < PTs.size(); ++i)
- Params[i] = ConvertExpressionToType(Params[i], PTs[i], VMC);
+ if (Params[i]->getType() != PTs[i]) {
+ // Create a cast to convert it to the right type, we know that this
+ // is a lossless cast...
+ //
+ Params[i] = new CastInst(Params[i], PTs[i], "call.resolve.cast");
+ It = BIL.insert(It, cast<Instruction>(Params[i]))+1;
+ }
Meth = NewVal; // Update call destination to new value
} else { // Changing an argument, must be in vararg area
projects / oota-llvm.git / blobdiff