Some small performance enhancments to InstCombineLoadStoreAlloca.cpp

[DaleEMartin]

Summary

I noticed a couple of small opportunities to bail earlier if we're going to bail.

[DaleEMartin]

My first attempt at using GitHub or Phabricator like this. Apologies for the noise - the changes in InstCombineLoadStoreAlloca.cpp are what I'd like feedback on.

[DaleEMartin]

I'll study this some more with the realization that it's causing unit test failures. Sorry for the noise.

.gitignore

 .cache
 # static analyzer regression testing project files
 /clang/utils/analyzer/projects/*/CachedSource
 /clang/utils/analyzer/projects/*/PatchedSource
 /clang/utils/analyzer/projects/*/ScanBuildResults
 /clang/utils/analyzer/projects/*/RefScanBuildResults
 # automodapi puts generated documentation files here.
 /lldb/docs/python_api/
+*.xcbuild
+*.a
+*.o
+*.dia
+*.d
+*.dat
+llvm/xcode/build/XCBuildData/*
+llvm/xcode/include/llvm/IR/LLVM.build/Debug/intrinsics_gen.build/Script-00566DF9EE997D9D0A1E1319.sh
+*.pbxproj
+*.LinkFileList
+*.sh
+*.pbxproj
+*.plist
+*.xcsettings
+llvm/xcode/LLVM.xcodeproj/project.xcworkspace/xcuserdata/dalemartin.xcuserdatad/UserInterfaceState.xcuserstate
+llvm/xcode/LLVM.xcodeproj/project.xcworkspace/xcshareddata/WorkspaceSettings.xcsettings
+llvm/xcode/LLVM.xcodeproj/project.pbxproj
+llvm/xcode/include/llvm/Support/VCSRevision.h
+llvm/xcode/include/llvm/IR/IntrinsicsXCore.h
+llvm/xcode/include/llvm/IR/IntrinsicsX86.h
+llvm/xcode/include/llvm/IR/IntrinsicsWebAssembly.h
+llvm/xcode/include/llvm/IR/IntrinsicsVE.h
+llvm/xcode/include/llvm/IR/IntrinsicsS390.h
+llvm/xcode/include/llvm/IR/IntrinsicsRISCV.h
+llvm/xcode/include/llvm/IR/IntrinsicsR600.h
+llvm/xcode/include/llvm/IR/IntrinsicsPowerPC.h
+llvm/xcode/include/llvm/IR/IntrinsicsNVPTX.h
+llvm/xcode/include/llvm/IR/IntrinsicsMips.h
+llvm/xcode/include/llvm/IR/IntrinsicsHexagon.h
+llvm/xcode/include/llvm/IR/IntrinsicsBPF.h
+llvm/xcode/include/llvm/IR/IntrinsicsARM.h
+llvm/xcode/include/llvm/IR/IntrinsicsAMDGPU.h
+llvm/xcode/include/llvm/IR/IntrinsicsAArch64.h
+llvm/xcode/include/llvm/IR/IntrinsicImpl.inc
+llvm/xcode/include/llvm/IR/IntrinsicEnums.inc
+llvm/xcode/include/llvm/IR/Attributes.inc
+llvm/xcode/Debug/bin/verify-uselistorder
+llvm/xcode/Debug/bin/llvm-tblgen
+llvm/xcode/LLVM.xcodeproj/.*

llvm/lib/Transforms/InstCombine/InstCombineLoadStoreAlloca.cpp

 //===- InstCombineLoadStoreAlloca.cpp -------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 //
isOnlyCopiedFromConstantMemory(AAResults *AA,
   SmallVector<std::pair<Value *, bool>, 35> ValuesToInspect;
   ValuesToInspect.emplace_back(V, false);
   while (!ValuesToInspect.empty()) {
     auto ValuePair = ValuesToInspect.pop_back_val();
     const bool IsOffset = ValuePair.second;
     for (auto &U : ValuePair.first->uses()) {
       auto *I = cast<Instruction>(U.getUser());
 
+      // If we already have seen aƒZThe copy, reject the second one.
+      if (TheCopy) return false;
+
       if (auto *LI = dyn_cast<LoadInst>(I)) {
         // Ignore non-volatile loads, they are always ok.
         if (!LI->isSimple()) return false;
         continue;
       }
 
       if (isa<BitCastInst>(I) || isa<AddrSpaceCastInst>(I)) {
         // If uses of the bitcast are ok, we are ok.
         ValuesToInspect.emplace_back(I, IsOffset);
         continue;
       }
       if (auto *GEP = dyn_cast<GetElementPtrInst>(I)) {
         // If the GEP has all zero indices, it doesn't offset the pointer. If it
         // doesn't, it does.
         ValuesToInspect.emplace_back(I, IsOffset || !GEP->hasAllZeroIndices());
         continue;
       }
 
+      // If the pointer has been offset from the start of the alloca, we can't
+      // safely handle this.
+      if (IsOffset) return false;
+
       if (auto *Call = dyn_cast<CallBase>(I)) {
         // If this is the function being called then we treat it like a load and
         // ignore it.
         if (Call->isCallee(&U))
           continue;
 
         unsigned DataOpNo = Call->getDataOperandNo(&U);
         bool IsArgOperand = Call->isArgOperand(&U);
for (auto &U : ValuePair.first->uses()) {
 
       // If the transfer is using the alloca as a source of the transfer, then
       // ignore it since it is a load (unless the transfer is volatile).
       if (U.getOperandNo() == 1) {
         if (MI->isVolatile()) return false;
         continue;
       }
 
-      // If we already have seen a copy, reject the second one.
-      if (TheCopy) return false;
-
-      // If the pointer has been offset from the start of the alloca, we can't
-      // safely handle this.
-      if (IsOffset) return false;
-
       // If the memintrinsic isn't using the alloca as the dest, reject it.
       if (U.getOperandNo() != 0) return false;
 
       // If the source of the memcpy/move is not a constant global, reject it.
       if (!AA->pointsToConstantMemory(MI->getSource()))
         return false;
 
       // Otherwise, the transform is safe.  Remember the copy instruction.