From fc239076731a654fcb54e427774dd12cd26e0b20 Mon Sep 17 00:00:00 2001 From: Ulrich Weigand Date: Thu, 7 Apr 2016 15:55:11 +0000 Subject: [PATCH] [GVN] Address review comments for D18662 As suggested by Chandler in his review comments for D18662, this follow-on patch renames some variables in GetLoadValueForLoad and CoerceAvailableValueToLoadType to hopefully make it more obvious which variables hold value sizes and which hold load/store sizes. No functional change intended. llvm-svn: 265687 --- llvm/lib/Transforms/Scalar/GVN.cpp | 19 ++++++++++--------- 1 file changed, 10 insertions(+), 9 deletions(-) diff --git a/llvm/lib/Transforms/Scalar/GVN.cpp b/llvm/lib/Transforms/Scalar/GVN.cpp index 121098f..c0b74fa 100644 --- a/llvm/lib/Transforms/Scalar/GVN.cpp +++ b/llvm/lib/Transforms/Scalar/GVN.cpp @@ -725,11 +725,11 @@ static Value *CoerceAvailableValueToLoadType(Value *StoredVal, Type *LoadedTy, // If this is already the right type, just return it. Type *StoredValTy = StoredVal->getType(); - uint64_t StoreSize = DL.getTypeSizeInBits(StoredValTy); - uint64_t LoadSize = DL.getTypeSizeInBits(LoadedTy); + uint64_t StoredValSize = DL.getTypeSizeInBits(StoredValTy); + uint64_t LoadedValSize = DL.getTypeSizeInBits(LoadedTy); // If the store and reload are the same size, we can always reuse it. - if (StoreSize == LoadSize) { + if (StoredValSize == LoadedValSize) { // Pointer to Pointer -> use bitcast. if (StoredValTy->getScalarType()->isPointerTy() && LoadedTy->getScalarType()->isPointerTy()) @@ -758,7 +758,8 @@ static Value *CoerceAvailableValueToLoadType(Value *StoredVal, Type *LoadedTy, // If the loaded value is smaller than the available value, then we can // extract out a piece from it. If the available value is too small, then we // can't do anything. - assert(StoreSize >= LoadSize && "CanCoerceMustAliasedValueToLoad fail"); + assert(StoredValSize >= LoadedValSize && + "CanCoerceMustAliasedValueToLoad fail"); // Convert source pointers to integers, which can be manipulated. if (StoredValTy->getScalarType()->isPointerTy()) { @@ -768,7 +769,7 @@ static Value *CoerceAvailableValueToLoadType(Value *StoredVal, Type *LoadedTy, // Convert vectors and fp to integer, which can be manipulated. if (!StoredValTy->isIntegerTy()) { - StoredValTy = IntegerType::get(StoredValTy->getContext(), StoreSize); + StoredValTy = IntegerType::get(StoredValTy->getContext(), StoredValSize); StoredVal = IRB.CreateBitCast(StoredVal, StoredValTy); } @@ -781,7 +782,7 @@ static Value *CoerceAvailableValueToLoadType(Value *StoredVal, Type *LoadedTy, } // Truncate the integer to the right size now. - Type *NewIntTy = IntegerType::get(StoredValTy->getContext(), LoadSize); + Type *NewIntTy = IntegerType::get(StoredValTy->getContext(), LoadedValSize); StoredVal = IRB.CreateTrunc(StoredVal, NewIntTy, "trunc"); if (LoadedTy == NewIntTy) @@ -1024,9 +1025,9 @@ static Value *GetLoadValueForLoad(LoadInst *SrcVal, unsigned Offset, const DataLayout &DL = SrcVal->getModule()->getDataLayout(); // If Offset+LoadTy exceeds the size of SrcVal, then we must be wanting to // widen SrcVal out to a larger load. - unsigned SrcValSize = DL.getTypeStoreSize(SrcVal->getType()); + unsigned SrcValStoreSize = DL.getTypeStoreSize(SrcVal->getType()); unsigned LoadSize = DL.getTypeStoreSize(LoadTy); - if (Offset+LoadSize > SrcValSize) { + if (Offset+LoadSize > SrcValStoreSize) { assert(SrcVal->isSimple() && "Cannot widen volatile/atomic load!"); assert(SrcVal->getType()->isIntegerTy() && "Can't widen non-integer load"); // If we have a load/load clobber an DepLI can be widened to cover this @@ -1058,7 +1059,7 @@ static Value *GetLoadValueForLoad(LoadInst *SrcVal, unsigned Offset, // system, we need to shift down to get the relevant bits. Value *RV = NewLoad; if (DL.isBigEndian()) - RV = Builder.CreateLShr(RV, (NewLoadSize - SrcValSize) * 8); + RV = Builder.CreateLShr(RV, (NewLoadSize - SrcValStoreSize) * 8); RV = Builder.CreateTrunc(RV, SrcVal->getType()); SrcVal->replaceAllUsesWith(RV); -- 2.7.4