SimplifyAllocas: search through more bitcasts to find alloca for llvm.dbg.declare.

lib/Transforms/NaCl/SimplifyAllocas.cpp

 //===- SimplifyAllocas.cpp - Simplify allocas to arrays of bytes         --===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 //
 // Simplify all allocas into allocas of byte arrays.
 //
 //===----------------------------------------------------------------------===//
 
 #include "llvm/IR/Constants.h"
 #include "llvm/IR/DataLayout.h"
 #include "llvm/IR/Function.h"
 #include "llvm/IR/Instructions.h"
 #include "llvm/IR/IntrinsicInst.h"
 #include "llvm/IR/Module.h"
 #include "llvm/Transforms/NaCl.h"
+#include "llvm/Support/Debug.h"
 #include "llvm/Support/raw_ostream.h"
+
 using namespace llvm;
 namespace {
 class SimplifyAllocas : public BasicBlockPass {
 public:
   static char ID; // Pass identification, replacement for typeid
   SimplifyAllocas()
       : BasicBlockPass(ID), Initialized(false), M(nullptr), IntPtrType(nullptr),
         Int8Type(nullptr), DL(nullptr) {
     initializeSimplifyAllocasPass(*PassRegistry::getPassRegistry());
   }
@@ skipping 11 matching lines @@
       M = F.getParent();
       DL = &M->getDataLayout();
       IntPtrType = DL->getIntPtrType(M->getContext());
       Int8Type = Type::getInt8Ty(M->getContext());
       Initialized = true;
       return true;
     }
     return false;
   }
 
+  AllocaInst *findAllocaFromBC(BitCastInst *BCInst) {
+    Value *Op0 = BCInst->getOperand(0);
+    while (!llvm::isa<AllocaInst>(Op0)) {
+      if (auto *NextBC = llvm::dyn_cast<BitCastInst>(Op0)) {
+        Op0 = NextBC->getOperand(0);
+      } else {
+        dbgs() << "findAllocaFromBC encountered a non-bitcast intermediate val "
+               << *Op0 << " starting w/ BCInst " << *BCInst << "\n";
+        report_fatal_error(
+            "findAllocaFromBC encountered a non-bitcast intermediate");
+      }
+    }
+    return llvm::cast<AllocaInst>(Op0);
+  }
+
   bool runOnBasicBlock(BasicBlock &BB) override {
     bool Changed = false;
     for (BasicBlock::iterator I = BB.getFirstInsertionPt(), E = BB.end();
          I != E;) {
       Instruction *Inst = &*I++;
       if (AllocaInst *Alloca = dyn_cast<AllocaInst>(Inst)) {
         Changed = true;
         Type *ElementTy = Alloca->getType()->getPointerElementType();
         Constant *ElementSize =
             ConstantInt::get(IntPtrType, DL->getTypeAllocSize(ElementTy));
@@ skipping 36 matching lines @@
         if (Call->getIntrinsicID() == Intrinsic::dbg_declare) {
           // dbg.declare's first argument is a special metadata that wraps a
           // value, and RAUW works on those. It is supposed to refer to the
           // alloca that represents the variable's storage, but the alloca
           // simplification may have RAUWed it to use the bitcast.
           // Fix it up here by recreating the metadata to use the new alloca.
           auto *MV = cast<MetadataAsValue>(Call->getArgOperand(0));
           // Sometimes dbg.declare points to an argument instead of an alloca.
           if (auto *VM = dyn_cast<ValueAsMetadata>(MV->getMetadata())) {
             if (auto *BCInst = dyn_cast<BitCastInst>(VM->getValue())) {
-              Value *CastSrc = BCInst->getOperand(0);
-              assert(isa<AllocaInst>(CastSrc));
+              AllocaInst *Alloca = findAllocaFromBC(BCInst);
               Call->setArgOperand(
                   0,
                   MetadataAsValue::get(Inst->getContext(),
-                                       ValueAsMetadata::get(CastSrc)));
+                                       ValueAsMetadata::get(Alloca)));
               Changed = true;
             }
           }
         }
       }
     }
     return Changed;
   }
 };
 }
 char SimplifyAllocas::ID = 0;
 
 INITIALIZE_PASS(SimplifyAllocas, "simplify-allocas",
                 "Simplify allocas to arrays of bytes", false, false)
 
 BasicBlockPass *llvm::createSimplifyAllocasPass() {
   return new SimplifyAllocas();
 }