Instrumented local variables and implemented runtime.

src/IceCfg.cpp

 //===- subzero/src/IceCfg.cpp - Control flow graph implementation ---------===//
 //
 //                        The Subzero Code Generator
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 ///
 /// \file
@@ skipping 729 matching lines @@
   CfgNode *EntryNode = getEntryNode();
   assert(EntryNode);
   // LLVM enforces power of 2 alignment.
   assert(llvm::isPowerOf2_32(StackAlignment));
   // Determine if there are large alignment allocations in the entry block or
   // dynamic allocations (variable size in the entry block).
   bool HasLargeAlignment = false;
   bool HasDynamicAllocation = false;
   for (Inst &Instr : EntryNode->getInsts()) {
     if (auto *Alloca = llvm::dyn_cast<InstAlloca>(&Instr)) {
+      if (Instr.isDeleted())
+        continue;
       uint32_t AlignmentParam = Alloca->getAlignInBytes();
       if (AlignmentParam > StackAlignment)
         HasLargeAlignment = true;
       if (llvm::isa<Constant>(Alloca->getSizeInBytes()))
         Alloca->setKnownFrameOffset();
       else {
         HasDynamicAllocation = true;
         // If Allocas are not sorted, the first dynamic allocation causes
         // later Allocas to be at unknown offsets relative to the stack/frame.
         if (!SortAndCombine)
           break;
       }
     }
   }
   // Don't do the heavyweight sorting and layout for low optimization levels.
   if (!SortAndCombine)
     return;
   // Any alloca outside the entry block is a dynamic allocation.
   for (CfgNode *Node : Nodes) {
     if (Node == EntryNode)
       continue;
     for (Inst &Instr : Node->getInsts()) {
-      if (llvm::isa<InstAlloca>(&Instr)) {
+      if (llvm::isa<InstAlloca>(&Instr) && !Instr.isDeleted()) {
         // Allocations outside the entry block require a frame pointer.
         HasDynamicAllocation = true;
         break;
       }
     }
     if (HasDynamicAllocation)
       break;
   }
   // Mark the target as requiring a frame pointer.
   if (HasLargeAlignment || HasDynamicAllocation)
     getTarget()->setHasFramePointer();
   // Collect the Allocas into the two vectors.
   // Allocas in the entry block that have constant size and alignment less
   // than or equal to the function's stack alignment.
   CfgVector<Inst *> FixedAllocas;
   // Allocas in the entry block that have constant size and alignment greater
   // than the function's stack alignment.
   CfgVector<Inst *> AlignedAllocas;
   // Maximum alignment used by any alloca.
   uint32_t MaxAlignment = StackAlignment;
   for (Inst &Instr : EntryNode->getInsts()) {
     if (auto *Alloca = llvm::dyn_cast<InstAlloca>(&Instr)) {
-      if (!llvm::isa<Constant>(Alloca->getSizeInBytes()))
+      if (!llvm::isa<Constant>(Alloca->getSizeInBytes()) || Alloca->isDeleted())
         continue;
       uint32_t AlignmentParam = Alloca->getAlignInBytes();
       // For default align=0, set it to the real value 1, to avoid any
       // bit-manipulation problems below.
       AlignmentParam = std::max(AlignmentParam, 1u);
       assert(llvm::isPowerOf2_32(AlignmentParam));
       if (HasDynamicAllocation && AlignmentParam > StackAlignment) {
         // If we have both dynamic allocations and large stack alignments,
         // high-alignment allocations are pulled out with their own base.
         AlignedAllocas.push_back(Alloca);
@@ skipping 805 matching lines @@
     }
   }
   // Print each basic block
   for (CfgNode *Node : Nodes)
     Node->dump(this);
   if (isVerbose(IceV_Instructions))
     Str << "}\n";
 }
 
 } // end of namespace Ice