more generic.
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@82402
91177308-0d34-0410-b5e6-
96231b3b80d8
/// CoerceAvailableValueToLoadType - If we saw a store of a value to memory, and
/// then a load from a must-aliased pointer of a different type, try to coerce
/// CoerceAvailableValueToLoadType - If we saw a store of a value to memory, and
/// then a load from a must-aliased pointer of a different type, try to coerce
-/// the stored value. If we can't do it, return null.
-static Value *CoerceAvailableValueToLoadType(Value *StoredVal, LoadInst *L,
+/// the stored value. LoadedTy is the type of the load we want to replace and
+/// InsertPt is the place to insert new instructions.
+///
+/// If we can't do it, return null.
+static Value *CoerceAvailableValueToLoadType(Value *StoredVal,
+ const Type *LoadedTy,
+ Instruction *InsertPt,
const TargetData &TD) {
const Type *StoredValTy = StoredVal->getType();
const TargetData &TD) {
const Type *StoredValTy = StoredVal->getType();
- const Type *LoadedTy = L->getType();
uint64_t StoreSize = TD.getTypeSizeInBits(StoredValTy);
uint64_t LoadSize = TD.getTypeSizeInBits(LoadedTy);
uint64_t StoreSize = TD.getTypeSizeInBits(StoredValTy);
uint64_t LoadSize = TD.getTypeSizeInBits(LoadedTy);
if (StoreSize == LoadSize) {
if (isa<PointerType>(StoredValTy) && isa<PointerType>(LoadedTy)) {
// Pointer to Pointer -> use bitcast.
if (StoreSize == LoadSize) {
if (isa<PointerType>(StoredValTy) && isa<PointerType>(LoadedTy)) {
// Pointer to Pointer -> use bitcast.
- return new BitCastInst(StoredVal, LoadedTy, "", L);
+ return new BitCastInst(StoredVal, LoadedTy, "", InsertPt);
}
// Convert source pointers to integers, which can be bitcast.
if (isa<PointerType>(StoredValTy)) {
StoredValTy = TD.getIntPtrType(StoredValTy->getContext());
}
// Convert source pointers to integers, which can be bitcast.
if (isa<PointerType>(StoredValTy)) {
StoredValTy = TD.getIntPtrType(StoredValTy->getContext());
- StoredVal = new PtrToIntInst(StoredVal, StoredValTy, "", L);
+ StoredVal = new PtrToIntInst(StoredVal, StoredValTy, "", InsertPt);
}
const Type *TypeToCastTo = LoadedTy;
}
const Type *TypeToCastTo = LoadedTy;
TypeToCastTo = TD.getIntPtrType(StoredValTy->getContext());
if (StoredValTy != TypeToCastTo)
TypeToCastTo = TD.getIntPtrType(StoredValTy->getContext());
if (StoredValTy != TypeToCastTo)
- StoredVal = new BitCastInst(StoredVal, TypeToCastTo, "", L);
+ StoredVal = new BitCastInst(StoredVal, TypeToCastTo, "", InsertPt);
// Cast to pointer if the load needs a pointer type.
if (isa<PointerType>(LoadedTy))
// Cast to pointer if the load needs a pointer type.
if (isa<PointerType>(LoadedTy))
- StoredVal = new IntToPtrInst(StoredVal, LoadedTy, "", L);
+ StoredVal = new IntToPtrInst(StoredVal, LoadedTy, "", InsertPt);
// Convert source pointers to integers, which can be manipulated.
if (isa<PointerType>(StoredValTy)) {
StoredValTy = TD.getIntPtrType(StoredValTy->getContext());
// Convert source pointers to integers, which can be manipulated.
if (isa<PointerType>(StoredValTy)) {
StoredValTy = TD.getIntPtrType(StoredValTy->getContext());
- StoredVal = new PtrToIntInst(StoredVal, StoredValTy, "", L);
+ StoredVal = new PtrToIntInst(StoredVal, StoredValTy, "", InsertPt);
}
// Convert vectors and fp to integer, which can be manipulated.
if (!isa<IntegerType>(StoredValTy)) {
StoredValTy = IntegerType::get(StoredValTy->getContext(), StoreSize);
}
// Convert vectors and fp to integer, which can be manipulated.
if (!isa<IntegerType>(StoredValTy)) {
StoredValTy = IntegerType::get(StoredValTy->getContext(), StoreSize);
- StoredVal = new BitCastInst(StoredVal, StoredValTy, "", L);
+ StoredVal = new BitCastInst(StoredVal, StoredValTy, "", InsertPt);
}
// If this is a big-endian system, we need to shift the value down to the low
// bits so that a truncate will work.
if (TD.isBigEndian()) {
Constant *Val = ConstantInt::get(StoredVal->getType(), StoreSize-LoadSize);
}
// If this is a big-endian system, we need to shift the value down to the low
// bits so that a truncate will work.
if (TD.isBigEndian()) {
Constant *Val = ConstantInt::get(StoredVal->getType(), StoreSize-LoadSize);
- StoredVal = BinaryOperator::CreateLShr(StoredVal, Val, "tmp", L);
+ StoredVal = BinaryOperator::CreateLShr(StoredVal, Val, "tmp", InsertPt);
}
// Truncate the integer to the right size now.
const Type *NewIntTy = IntegerType::get(StoredValTy->getContext(), LoadSize);
}
// Truncate the integer to the right size now.
const Type *NewIntTy = IntegerType::get(StoredValTy->getContext(), LoadSize);
- StoredVal = new TruncInst(StoredVal, NewIntTy, "trunc", L);
+ StoredVal = new TruncInst(StoredVal, NewIntTy, "trunc", InsertPt);
if (LoadedTy == NewIntTy)
return StoredVal;
// If the result is a pointer, inttoptr.
if (isa<PointerType>(LoadedTy))
if (LoadedTy == NewIntTy)
return StoredVal;
// If the result is a pointer, inttoptr.
if (isa<PointerType>(LoadedTy))
- return new IntToPtrInst(StoredVal, LoadedTy, "inttoptr", L);
+ return new IntToPtrInst(StoredVal, LoadedTy, "inttoptr", InsertPt);
- return new BitCastInst(StoredVal, LoadedTy, "bitcast", L);
+ return new BitCastInst(StoredVal, LoadedTy, "bitcast", InsertPt);
const TargetData *TD = 0;
if (StoredVal->getType() != L->getType() &&
(TD = getAnalysisIfAvailable<TargetData>())) {
const TargetData *TD = 0;
if (StoredVal->getType() != L->getType() &&
(TD = getAnalysisIfAvailable<TargetData>())) {
- StoredVal = CoerceAvailableValueToLoadType(StoredVal, L, *TD);
+ StoredVal = CoerceAvailableValueToLoadType(StoredVal, L->getType(), L, *TD);
if (StoredVal == 0)
return false;
if (StoredVal == 0)
return false;
const TargetData *TD = 0;
if (DepLI->getType() != L->getType() &&
(TD = getAnalysisIfAvailable<TargetData>())) {
const TargetData *TD = 0;
if (DepLI->getType() != L->getType() &&
(TD = getAnalysisIfAvailable<TargetData>())) {
- AvailableVal = CoerceAvailableValueToLoadType(DepLI, L, *TD);
+ AvailableVal = CoerceAvailableValueToLoadType(DepLI, L->getType(), L, *TD);
if (AvailableVal == 0)
return false;
if (AvailableVal == 0)
return false;
// FIXME: We should handle memset/memcpy/memmove as dependent instructions to
// forward the value if available.
// FIXME: We should handle memset/memcpy/memmove as dependent instructions to
// forward the value if available.
+ //if (isa<MemIntrinsic>(DepInst))
+ // errs() << "LOAD DEPENDS ON MEM: " << *L << "\n" << *DepInst << "\n\n";
// If this load really doesn't depend on anything, then we must be loading an
// If this load really doesn't depend on anything, then we must be loading an