[SafeStack,NFC] Fix names after files move

[vitalybuka]

Summary

Depends on D81831.

[eugenis]

LGTM

llvm/include/llvm/Analysis/StackLifetime.h

-//===- SafeStackColoring.h - SafeStack frame coloring ----------*- C++ -*--===//
+//===- StackLifetime.h - Alloca Lifetime Analysis --------------*- C++ -*--===//
 //
 // 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
 //
 //===----------------------------------------------------------------------===//
 
-#ifndef LLVM_LIB_CODEGEN_SAFESTACKCOLORING_H
-#define LLVM_LIB_CODEGEN_SAFESTACKCOLORING_H
+#ifndef LLVM_ANALYSIS_STACKLIFETIME_H
+#define LLVM_ANALYSIS_STACKLIFETIME_H
 
 #include "llvm/ADT/ArrayRef.h"
 #include "llvm/ADT/BitVector.h"
 #include "llvm/ADT/DenseMap.h"
 #include "llvm/ADT/SmallVector.h"
 #include "llvm/IR/IntrinsicInst.h"
 #include "llvm/Support/raw_ostream.h"
 #include <cassert>
 #include <utility>
 
 namespace llvm {
 
 class AllocaInst;
 class BasicBlock;
 class Function;
 class Instruction;
 
-namespace safestack {
-
 /// Compute live ranges of allocas.
 /// Live ranges are represented as sets of "interesting" instructions, which are
 /// defined as instructions that may start or end an alloca's lifetime. These
 /// are:
 /// * lifetime.start and lifetime.end intrinsics
 /// * first instruction of any basic block
 /// Interesting instructions are numbered in the depth-first walk of the CFG,
 /// and in the program order inside each basic block.
-class StackColoring {
+class StackLifetime {
   /// A class representing liveness information for a single basic block.
   /// Each bit in the BitVector represents the liveness property
   /// for a different stack slot.
   struct BlockLifetimeInfo {
     explicit BlockLifetimeInfo(unsigned Size)
         : Begin(Size), End(Size), LiveIn(Size), LiveOut(Size) {}
 
     /// Which slots BEGINs in each basic block.
class StackLifetime {
   };
 
 public:
   /// This class represents a set of interesting instructions where an alloca is
   /// live.
   class LiveRange {
     BitVector Bits;
     friend raw_ostream &operator<<(raw_ostream &OS,
-                                   const StackColoring::LiveRange &R);
+                                   const StackLifetime::LiveRange &R);
 
   public:
     LiveRange(unsigned Size, bool Set = false) : Bits(Size, Set) {}
     void addRange(unsigned Start, unsigned End) { Bits.set(Start, End); }
 
     bool overlaps(const LiveRange &Other) const {
       return Bits.anyCommon(Other.Bits);
     }
private:
   void dumpBlockLiveness() const;
   void dumpLiveRanges() const;
 
   void collectMarkers();
   void calculateLocalLiveness();
   void calculateLiveIntervals();
 
 public:
-  StackColoring(const Function &F, ArrayRef<const AllocaInst *> Allocas);
+  StackLifetime(const Function &F, ArrayRef<const AllocaInst *> Allocas);
 
   void run();
   std::vector<const IntrinsicInst *> getMarkers() const;
 
   /// Returns a set of "interesting" instructions where the given alloca is
   /// live. Not all instructions in a function are interesting: we pick a set
   /// that is large enough for LiveRange::Overlaps to be correct.
   const LiveRange &getLiveRange(const AllocaInst *AI) const;
while (Idx >= 0) {
     OS << Idx;
     Idx = V.find_next(Idx);
   }
   OS << "}";
   return OS;
 }
 
 inline raw_ostream &operator<<(raw_ostream &OS,
-                               const StackColoring::LiveRange &R) {
+                               const StackLifetime::LiveRange &R) {
   return OS << R.Bits;
 }
 
-} // end namespace safestack
-
 } // end namespace llvm
 
-#endif // LLVM_LIB_CODEGEN_SAFESTACKCOLORING_H
+#endif // LLVM_ANALYSIS_STACKLIFETIME_H

llvm/lib/Analysis/StackLifetime.cpp

-//===- SafeStackColoring.cpp - SafeStack frame coloring -------------------===//
+//===- StackLifetime.cpp - Alloca Lifetime Analysis -----------------------===//
 //
 // 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
 //
 //===----------------------------------------------------------------------===//
 
 #include "llvm/Analysis/StackLifetime.h"
 #include "llvm/ADT/DepthFirstIterator.h"
 #include "llvm/Config/llvm-config.h"
 #include "llvm/IR/BasicBlock.h"
 #include "llvm/IR/CFG.h"
 #include "llvm/IR/Instructions.h"
 #include "llvm/IR/IntrinsicInst.h"
 #include "llvm/IR/Intrinsics.h"
 #include "llvm/IR/User.h"
 #include "llvm/Support/Casting.h"
 #include "llvm/Support/CommandLine.h"
 #include "llvm/Support/Compiler.h"
 #include "llvm/Support/Debug.h"
 #include <tuple>
 
 using namespace llvm;
-using namespace llvm::safestack;
 
-#define DEBUG_TYPE "safestackcoloring"
+#define DEBUG_TYPE "stack-lifetime"
 
-const StackColoring::LiveRange &
-StackColoring::getLiveRange(const AllocaInst *AI) const {
+const StackLifetime::LiveRange &
+StackLifetime::getLiveRange(const AllocaInst *AI) const {
   const auto IT = AllocaNumbering.find(AI);
   assert(IT != AllocaNumbering.end());
   return LiveRanges[IT->second];
 }
 
 static bool readMarker(const Instruction *I, bool *IsStart) {
   if (!I->isLifetimeStartOrEnd())
     return false;
 
   auto *II = cast<IntrinsicInst>(I);
   *IsStart = II->getIntrinsicID() == Intrinsic::lifetime_start;
   return true;
 }
 
-std::vector<const IntrinsicInst *> StackColoring::getMarkers() const {
+std::vector<const IntrinsicInst *> StackLifetime::getMarkers() const {
   std::vector<const IntrinsicInst *> Markers;
   for (auto &M : InstructionNumbering)
     if (M.getFirst()->isLifetimeStartOrEnd())
       Markers.push_back(M.getFirst());
   return Markers;
 }
 
-void StackColoring::collectMarkers() {
+void StackLifetime::collectMarkers() {
   InterestingAllocas.resize(NumAllocas);
   DenseMap<const BasicBlock *, SmallDenseMap<const IntrinsicInst *, Marker>>
       BBMarkerSet;
 
   // Compute the set of start/end markers per basic block.
   for (unsigned AllocaNo = 0; AllocaNo < NumAllocas; ++AllocaNo) {
     const AllocaInst *AI = Allocas[AllocaNo];
     SmallVector<const Instruction *, 8> WorkList;
for (const BasicBlock *BB : depth_first(&F)) {
     }
 
     unsigned BBEnd = InstNo;
     BlockInstRange[BB] = std::make_pair(BBStart, BBEnd);
   }
   NumInst = InstNo;
 }
 
-void StackColoring::calculateLocalLiveness() {
+void StackLifetime::calculateLocalLiveness() {
   bool Changed = true;
   while (Changed) {
     Changed = false;
 
     for (const BasicBlock *BB : depth_first(&F)) {
       BlockLifetimeInfo &BlockInfo = BlockLiveness.find(BB)->getSecond();
 
       // Compute LiveIn by unioning together the LiveOut sets of all preds.
for (const BasicBlock *BB : depth_first(&F)) {
       if (LocalLiveOut.test(BlockInfo.LiveOut)) {
         Changed = true;
         BlockInfo.LiveOut |= LocalLiveOut;
       }
     }
   } // while changed.
 }
 
-void StackColoring::calculateLiveIntervals() {
+void StackLifetime::calculateLiveIntervals() {
   for (auto IT : BlockLiveness) {
     const BasicBlock *BB = IT.getFirst();
     BlockLifetimeInfo &BlockInfo = IT.getSecond();
     unsigned BBStart, BBEnd;
     std::tie(BBStart, BBEnd) = BlockInstRange[BB];
 
     BitVector Started, Ended;
     Started.resize(NumAllocas);
for (auto IT : BlockLiveness) {
 
     for (unsigned AllocaNo = 0; AllocaNo < NumAllocas; ++AllocaNo)
       if (Started.test(AllocaNo))
         LiveRanges[AllocaNo].addRange(Start[AllocaNo], BBEnd);
   }
 }
 
 #if !defined(NDEBUG) || defined(LLVM_ENABLE_DUMP)
-LLVM_DUMP_METHOD void StackColoring::dumpAllocas() const {
+LLVM_DUMP_METHOD void StackLifetime::dumpAllocas() const {
   dbgs() << "Allocas:\n";
   for (unsigned AllocaNo = 0; AllocaNo < NumAllocas; ++AllocaNo)
     dbgs() << "  " << AllocaNo << ": " << *Allocas[AllocaNo] << "\n";
 }
 
-LLVM_DUMP_METHOD void StackColoring::dumpBlockLiveness() const {
+LLVM_DUMP_METHOD void StackLifetime::dumpBlockLiveness() const {
   dbgs() << "Block liveness:\n";
   for (auto IT : BlockLiveness) {
     const BasicBlock *BB = IT.getFirst();
     const BlockLifetimeInfo &BlockInfo = BlockLiveness.find(BB)->getSecond();
     auto BlockRange = BlockInstRange.find(BB)->getSecond();
     dbgs() << "  BB [" << BlockRange.first << ", " << BlockRange.second
            << "): begin " << BlockInfo.Begin << ", end " << BlockInfo.End
            << ", livein " << BlockInfo.LiveIn << ", liveout "
            << BlockInfo.LiveOut << "\n";
   }
 }
 
-LLVM_DUMP_METHOD void StackColoring::dumpLiveRanges() const {
+LLVM_DUMP_METHOD void StackLifetime::dumpLiveRanges() const {
   dbgs() << "Alloca liveness:\n";
   for (unsigned AllocaNo = 0; AllocaNo < NumAllocas; ++AllocaNo)
     dbgs() << "  " << AllocaNo << ": " << LiveRanges[AllocaNo] << "\n";
 }
 #endif
 
-StackColoring::StackColoring(const Function &F,
+StackLifetime::StackLifetime(const Function &F,
                              ArrayRef<const AllocaInst *> Allocas)
     : F(F), Allocas(Allocas), NumAllocas(Allocas.size()) {
   LLVM_DEBUG(dumpAllocas());
 
   for (unsigned I = 0; I < NumAllocas; ++I)
     AllocaNumbering[Allocas[I]] = I;
 
   collectMarkers();
 }
 
-void StackColoring::run() {
+void StackLifetime::run() {
   LiveRanges.resize(NumAllocas, LiveRange(NumInst));
   for (unsigned I = 0; I < NumAllocas; ++I)
     if (!InterestingAllocas.test(I))
       LiveRanges[I] = getFullLiveRange();
 
   calculateLocalLiveness();
   LLVM_DEBUG(dumpBlockLiveness());
   calculateLiveIntervals();
   LLVM_DEBUG(dumpLiveRanges());
 }

llvm/lib/CodeGen/SafeStack.cpp

Value *SafeStack::moveStaticAllocasToUnsafeStack(
     IRBuilder<> &IRB, Function &F, ArrayRef<AllocaInst *> StaticAllocas,
     ArrayRef<Argument *> ByValArguments, ArrayRef<ReturnInst *> Returns,
     Instruction *BasePointer, AllocaInst *StackGuardSlot) {
   if (StaticAllocas.empty() && ByValArguments.empty())
     return BasePointer;
 
   DIBuilder DIB(*F.getParent());
 
-  StackColoring SSC(F, StaticAllocas);
-  static const StackColoring::LiveRange NoColoringRange(1, true);
+  StackLifetime SSC(F, StaticAllocas);
+  static const StackLifetime::LiveRange NoColoringRange(1, true);
   if (ClColoring)
     SSC.run();
 
   for (auto *I : SSC.getMarkers()) {
     auto *Op = dyn_cast<Instruction>(I->getOperand(1));
     const_cast<IntrinsicInst *>(I)->eraseFromParent();
     // Remove the operand bitcast, too, if it has no more uses left.
     if (Op && Op->use_empty())

llvm/lib/CodeGen/SafeStackLayout.h

 
 /// Compute the layout of an unsafe stack frame.
 class StackLayout {
   unsigned MaxAlignment;
 
   struct StackRegion {
     unsigned Start;
     unsigned End;
-    StackColoring::LiveRange Range;
+    StackLifetime::LiveRange Range;
 
     StackRegion(unsigned Start, unsigned End,
-                const StackColoring::LiveRange &Range)
+                const StackLifetime::LiveRange &Range)
         : Start(Start), End(End), Range(Range) {}
   };
 
   /// The list of current stack regions, sorted by StackRegion::Start.
   SmallVector<StackRegion, 16> Regions;
 
   struct StackObject {
     const Value *Handle;
     unsigned Size, Alignment;
-    StackColoring::LiveRange Range;
+    StackLifetime::LiveRange Range;
   };
 
   SmallVector<StackObject, 8> StackObjects;
 
   DenseMap<const Value *, unsigned> ObjectOffsets;
   DenseMap<const Value *, unsigned> ObjectAlignments;
 
   void layoutObject(StackObject &Obj);
 
 public:
   StackLayout(unsigned StackAlignment) : MaxAlignment(StackAlignment) {}
 
   /// Add an object to the stack frame. Value pointer is opaque and used as a
   /// handle to retrieve the object's offset in the frame later.
   void addObject(const Value *V, unsigned Size, unsigned Alignment,
-                 const StackColoring::LiveRange &Range);
+                 const StackLifetime::LiveRange &Range);
 
   /// Run the layout computation for all previously added objects.
   void computeLayout();
 
   /// Returns the offset to the object start in the stack frame.
   unsigned getObjectOffset(const Value *V) { return ObjectOffsets[V]; }
 
   /// Returns the alignment of the object

llvm/lib/CodeGen/SafeStackLayout.cpp

LLVM_DUMP_METHOD void StackLayout::print(raw_ostream &OS) {
   }
   OS << "Stack objects:\n";
   for (auto &IT : ObjectOffsets) {
     OS << "  at " << IT.getSecond() << ": " << *IT.getFirst() << "\n";
   }
 }
 
 void StackLayout::addObject(const Value *V, unsigned Size, unsigned Alignment,
-                            const StackColoring::LiveRange &Range) {
+                            const StackLifetime::LiveRange &Range) {
   StackObjects.push_back({V, Size, Alignment, Range});
   ObjectAlignments[V] = Alignment;
   MaxAlignment = std::max(MaxAlignment, Alignment);
 }
 
 static unsigned AdjustStackOffset(unsigned Offset, unsigned Size,
                                   unsigned Alignment) {
   return alignTo(Offset + Size, Alignment) - Size;
void StackLayout::layoutObject(StackObject &Obj) {
   }
 
   unsigned LastRegionEnd = Regions.empty() ? 0 : Regions.back().End;
   if (End > LastRegionEnd) {
     // Insert a new region at the end. Maybe two.
     if (Start > LastRegionEnd) {
       LLVM_DEBUG(dbgs() << "  Creating gap region: " << LastRegionEnd << " .. "
                         << Start << "\n");
-      Regions.emplace_back(LastRegionEnd, Start, StackColoring::LiveRange(0));
+      Regions.emplace_back(LastRegionEnd, Start, StackLifetime::LiveRange(0));
       LastRegionEnd = Start;
     }
     LLVM_DEBUG(dbgs() << "  Creating new region: " << LastRegionEnd << " .. "
                       << End << ", range " << Obj.Range << "\n");
     Regions.emplace_back(LastRegionEnd, End, Obj.Range);
     LastRegionEnd = End;
   }