From 5eca075b74d62c621b160aa216b4cd50829a2cc7 Mon Sep 17 00:00:00 2001 From: Gordon Henriksen Date: Sun, 17 Aug 2008 18:44:35 +0000 Subject: Rename some GC classes so that their roll will hopefully be clearer. In particular, Collector was confusing to implementors. Several thought that this compile-time class was the place to implement their runtime GC heap. Of course, it doesn't even exist at runtime. Specifically, the renames are: Collector -> GCStrategy CollectorMetadata -> GCFunctionInfo CollectorModuleMetadata -> GCModuleInfo CollectorRegistry -> GCRegistry Function::getCollector -> getGC (setGC, hasGC, clearGC) Several accessors and nested types have also been renamed to be consistent. These changes should be obvious. git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@54899 91177308-0d34-0410-b5e6-96231b3b80d8 --- lib/CodeGen/AsmPrinter/AsmPrinter.cpp | 46 +++++------ lib/CodeGen/AsmPrinter/OcamlGCPrinter.cpp | 58 +++++++------- lib/CodeGen/GCMetadata.cpp | 104 ++++++++++++------------- lib/CodeGen/GCMetadataPrinter.cpp | 18 ++++- lib/CodeGen/GCStrategy.cpp | 107 ++++++++++++++------------ lib/CodeGen/GCs.cpp | 28 ------- lib/CodeGen/LLVMTargetMachine.cpp | 8 +- lib/CodeGen/OcamlGC.cpp | 27 +++---- lib/CodeGen/SelectionDAG/SelectionDAGISel.cpp | 35 +++++---- lib/CodeGen/ShadowStackGC.cpp | 49 ++++++------ 10 files changed, 226 insertions(+), 254 deletions(-) delete mode 100644 lib/CodeGen/GCs.cpp (limited to 'lib/CodeGen') diff --git a/lib/CodeGen/AsmPrinter/AsmPrinter.cpp b/lib/CodeGen/AsmPrinter/AsmPrinter.cpp index de31840d70..380b3bc214 100644 --- a/lib/CodeGen/AsmPrinter/AsmPrinter.cpp +++ b/lib/CodeGen/AsmPrinter/AsmPrinter.cpp @@ -16,9 +16,7 @@ #include "llvm/DerivedTypes.h" #include "llvm/Constants.h" #include "llvm/Module.h" -#include "llvm/CodeGen/GCStrategy.h" -#include "llvm/CodeGen/GCMetadata.h" -#include "llvm/CodeGen/GCs.h" +#include "llvm/CodeGen/GCMetadataPrinter.h" #include "llvm/CodeGen/MachineConstantPool.h" #include "llvm/CodeGen/MachineJumpTableInfo.h" #include "llvm/CodeGen/MachineModuleInfo.h" @@ -110,18 +108,17 @@ void AsmPrinter::SwitchToDataSection(const char *NewSection, void AsmPrinter::getAnalysisUsage(AnalysisUsage &AU) const { MachineFunctionPass::getAnalysisUsage(AU); - AU.addRequired(); + AU.addRequired(); } bool AsmPrinter::doInitialization(Module &M) { Mang = new Mangler(M, TAI->getGlobalPrefix()); - CollectorModuleMetadata *CMM = getAnalysisToUpdate(); - assert(CMM && "AsmPrinter didn't require CollectorModuleMetadata?"); - for (CollectorModuleMetadata::iterator I = CMM->begin(), - E = CMM->end(); I != E; ++I) - if (GCMetadataPrinter *GCP = GetOrCreateGCPrinter(*I)) - GCP->beginAssembly(O, *this, *TAI); + GCModuleInfo *MI = getAnalysisToUpdate(); + assert(MI && "AsmPrinter didn't require GCModuleInfo?"); + for (GCModuleInfo::iterator I = MI->begin(), E = MI->end(); I != E; ++I) + if (GCMetadataPrinter *MP = GetOrCreateGCPrinter(*I)) + MP->beginAssembly(O, *this, *TAI); if (!M.getModuleInlineAsm().empty()) O << TAI->getCommentString() << " Start of file scope inline assembly\n" @@ -192,12 +189,11 @@ bool AsmPrinter::doFinalization(Module &M) { } } - CollectorModuleMetadata *CMM = getAnalysisToUpdate(); - assert(CMM && "AsmPrinter didn't require CollectorModuleMetadata?"); - for (CollectorModuleMetadata::iterator I = CMM->end(), - E = CMM->begin(); I != E; ) - if (GCMetadataPrinter *GCP = GetOrCreateGCPrinter(*--I)) - GCP->finishAssembly(O, *this, *TAI); + GCModuleInfo *MI = getAnalysisToUpdate(); + assert(MI && "AsmPrinter didn't require GCModuleInfo?"); + for (GCModuleInfo::iterator I = MI->end(), E = MI->begin(); I != E; ) + if (GCMetadataPrinter *MP = GetOrCreateGCPrinter(*--I)) + MP->finishAssembly(O, *this, *TAI); // If we don't have any trampolines, then we don't require stack memory // to be executable. Some targets have a directive to declare this. @@ -1466,26 +1462,26 @@ void AsmPrinter::printVisibility(const std::string& Name, } } -GCMetadataPrinter *AsmPrinter::GetOrCreateGCPrinter(Collector *C) { - if (!C->usesMetadata()) +GCMetadataPrinter *AsmPrinter::GetOrCreateGCPrinter(GCStrategy *S) { + if (!S->usesMetadata()) return 0; - gcp_iterator GCPI = GCMetadataPrinters.find(C); + gcp_iterator GCPI = GCMetadataPrinters.find(S); if (GCPI != GCMetadataPrinters.end()) return GCPI->second; - const char *Name = C->getName().c_str(); + const char *Name = S->getName().c_str(); for (GCMetadataPrinterRegistry::iterator I = GCMetadataPrinterRegistry::begin(), E = GCMetadataPrinterRegistry::end(); I != E; ++I) if (strcmp(Name, I->getName()) == 0) { - GCMetadataPrinter *GCP = I->instantiate(); - GCP->Coll = C; - GCMetadataPrinters.insert(std::make_pair(C, GCP)); - return GCP; + GCMetadataPrinter *GMP = I->instantiate(); + GMP->S = S; + GCMetadataPrinters.insert(std::make_pair(S, GMP)); + return GMP; } - cerr << "no GCMetadataPrinter registered for collector: " << Name << "\n"; + cerr << "no GCMetadataPrinter registered for GC: " << Name << "\n"; abort(); } diff --git a/lib/CodeGen/AsmPrinter/OcamlGCPrinter.cpp b/lib/CodeGen/AsmPrinter/OcamlGCPrinter.cpp index efa7f67276..42f1a0fe92 100644 --- a/lib/CodeGen/AsmPrinter/OcamlGCPrinter.cpp +++ b/lib/CodeGen/AsmPrinter/OcamlGCPrinter.cpp @@ -1,4 +1,4 @@ -//===-- OcamlCollector.cpp - Ocaml frametable emitter ---------------------===// +//===-- OcamlGCPrinter.cpp - Ocaml frametable emitter ---------------------===// // // The LLVM Compiler Infrastructure // @@ -7,13 +7,13 @@ // //===----------------------------------------------------------------------===// // -// This file implements lowering for the llvm.gc* intrinsics compatible with -// Objective Caml 3.10.0, which uses a liveness-accurate static stack map. +// This file implements printing the assembly code for an Ocaml frametable. // //===----------------------------------------------------------------------===// #include "llvm/CodeGen/GCs.h" #include "llvm/CodeGen/AsmPrinter.h" +#include "llvm/CodeGen/GCMetadataPrinter.h" #include "llvm/CodeGen/GCStrategy.h" #include "llvm/Module.h" #include "llvm/Target/TargetAsmInfo.h" @@ -38,9 +38,7 @@ namespace { static GCMetadataPrinterRegistry::Add Y("ocaml", "ocaml 3.10-compatible collector"); -GCMetadataPrinter *llvm::createOcamlMetadataPrinter() { - return new OcamlGCMetadataPrinter(); -} +void llvm::linkOcamlGCPrinter() { } static void EmitCamlGlobal(const Module &M, std::ostream &OS, AsmPrinter &AP, const TargetAsmInfo &TAI, const char *Id) { @@ -85,7 +83,7 @@ void OcamlGCMetadataPrinter::beginAssembly(std::ostream &OS, AsmPrinter &AP, /// /// Note that this precludes programs from stack frames larger than 64K /// (FrameSize and LiveOffsets would overflow). FrameTablePrinter will abort if -/// either condition is detected in a function which uses the collector. +/// either condition is detected in a function which uses the GC. /// void OcamlGCMetadataPrinter::finishAssembly(std::ostream &OS, AsmPrinter &AP, const TargetAsmInfo &TAI) { @@ -111,33 +109,32 @@ void OcamlGCMetadataPrinter::finishAssembly(std::ostream &OS, AsmPrinter &AP, AP.SwitchToDataSection(TAI.getDataSection()); EmitCamlGlobal(getModule(), OS, AP, TAI, "frametable"); - for (iterator FI = begin(), FE = end(); FI != FE; ++FI) { - CollectorMetadata &MD = **FI; + for (iterator I = begin(), IE = end(); I != IE; ++I) { + GCFunctionInfo &FI = **I; + + uint64_t FrameSize = FI.getFrameSize(); + if (FrameSize >= 1<<16) { + cerr << "Function '" << FI.getFunction().getNameStart() + << "' is too large for the ocaml GC! " + << "Frame size " << FrameSize << " >= 65536.\n"; + cerr << "(" << uintptr_t(&FI) << ")\n"; + abort(); // Very rude! + } OS << "\t" << TAI.getCommentString() << " live roots for " - << MD.getFunction().getNameStart() << "\n"; + << FI.getFunction().getNameStart() << "\n"; - for (CollectorMetadata::iterator PI = MD.begin(), - PE = MD.end(); PI != PE; ++PI) { - - uint64_t FrameSize = MD.getFrameSize(); - if (FrameSize >= 1<<16) { - cerr << "Function '" << MD.getFunction().getNameStart() - << "' is too large for the ocaml collector! " - << "Frame size " << FrameSize << " >= 65536.\n"; - abort(); // Very rude! - } - - size_t LiveCount = MD.live_size(PI); + for (GCFunctionInfo::iterator J = FI.begin(), JE = FI.end(); J != JE; ++J) { + size_t LiveCount = FI.live_size(J); if (LiveCount >= 1<<16) { - cerr << "Function '" << MD.getFunction().getNameStart() - << "' is too large for the ocaml collector! " + cerr << "Function '" << FI.getFunction().getNameStart() + << "' is too large for the ocaml GC! " << "Live root count " << LiveCount << " >= 65536.\n"; abort(); // Very rude! } OS << AddressDirective - << TAI.getPrivateGlobalPrefix() << "label" << PI->Num; + << TAI.getPrivateGlobalPrefix() << "label" << J->Num; AP.EOL("call return address"); AP.EmitInt16(FrameSize); @@ -146,14 +143,13 @@ void OcamlGCMetadataPrinter::finishAssembly(std::ostream &OS, AsmPrinter &AP, AP.EmitInt16(LiveCount); AP.EOL("live root count"); - for (CollectorMetadata::live_iterator LI = MD.live_begin(PI), - LE = MD.live_end(PI); - LI != LE; ++LI) { - assert(LI->StackOffset < 1<<16 && + for (GCFunctionInfo::live_iterator K = FI.live_begin(J), + KE = FI.live_end(J); K != KE; ++K) { + assert(K->StackOffset < 1<<16 && "GC root stack offset is outside of fixed stack frame and out " - "of range for Ocaml collector!"); + "of range for ocaml GC!"); - OS << "\t.word\t" << LI->StackOffset; + OS << "\t.word\t" << K->StackOffset; AP.EOL("stack offset"); } diff --git a/lib/CodeGen/GCMetadata.cpp b/lib/CodeGen/GCMetadata.cpp index 0b5c6f0662..efb89e128e 100644 --- a/lib/CodeGen/GCMetadata.cpp +++ b/lib/CodeGen/GCMetadata.cpp @@ -1,4 +1,4 @@ -//===-- CollectorMetadata.cpp - Garbage collector metadata ----------------===// +//===-- GCMetadata.cpp - Garbage collector metadata -----------------------===// // // The LLVM Compiler Infrastructure // @@ -7,14 +7,12 @@ // //===----------------------------------------------------------------------===// // -// This file implements the CollectorMetadata and CollectorModuleMetadata -// classes. +// This file implements the GCFunctionInfo class and GCModuleInfo pass. // //===----------------------------------------------------------------------===// #include "llvm/CodeGen/GCMetadata.h" #include "llvm/CodeGen/GCStrategy.h" -#include "llvm/CodeGen/GCs.h" #include "llvm/CodeGen/MachineFrameInfo.h" #include "llvm/Pass.h" #include "llvm/CodeGen/Passes.h" @@ -53,79 +51,80 @@ namespace { } -static RegisterPass +static RegisterPass X("collector-metadata", "Create Garbage Collector Module Metadata"); // ----------------------------------------------------------------------------- -CollectorMetadata::CollectorMetadata(const Function &F, Collector &C) - : F(F), C(C), FrameSize(~0LL) {} +GCFunctionInfo::GCFunctionInfo(const Function &F, GCStrategy &S) + : F(F), S(S), FrameSize(~0LL) {} -CollectorMetadata::~CollectorMetadata() {} +GCFunctionInfo::~GCFunctionInfo() {} // ----------------------------------------------------------------------------- -char CollectorModuleMetadata::ID = 0; +char GCModuleInfo::ID = 0; -CollectorModuleMetadata::CollectorModuleMetadata() +GCModuleInfo::GCModuleInfo() : ImmutablePass((intptr_t)&ID) {} -CollectorModuleMetadata::~CollectorModuleMetadata() { +GCModuleInfo::~GCModuleInfo() { clear(); } -Collector *CollectorModuleMetadata:: -getOrCreateCollector(const Module *M, const std::string &Name) { +GCStrategy *GCModuleInfo::getOrCreateStrategy(const Module *M, + const std::string &Name) { const char *Start = Name.c_str(); - collector_map_type::iterator NMI = NameMap.find(Start, Start + Name.size()); - if (NMI != NameMap.end()) + strategy_map_type::iterator NMI = + StrategyMap.find(Start, Start + Name.size()); + if (NMI != StrategyMap.end()) return NMI->getValue(); - for (CollectorRegistry::iterator I = CollectorRegistry::begin(), - E = CollectorRegistry::end(); I != E; ++I) { + for (GCRegistry::iterator I = GCRegistry::begin(), + E = GCRegistry::end(); I != E; ++I) { if (strcmp(Start, I->getName()) == 0) { - Collector *C = I->instantiate(); - C->M = M; - C->Name = Name; - NameMap.GetOrCreateValue(Start, Start + Name.size()).setValue(C); - Collectors.push_back(C); - return C; + GCStrategy *S = I->instantiate(); + S->M = M; + S->Name = Name; + StrategyMap.GetOrCreateValue(Start, Start + Name.size()).setValue(S); + StrategyList.push_back(S); + return S; } } - cerr << "unsupported collector: " << Name << "\n"; + cerr << "unsupported GC: " << Name << "\n"; abort(); } -CollectorMetadata &CollectorModuleMetadata::get(const Function &F) { +GCFunctionInfo &GCModuleInfo::getFunctionInfo(const Function &F) { assert(!F.isDeclaration() && "Can only get GCFunctionInfo for a definition!"); - assert(F.hasCollector()); + assert(F.hasGC()); - function_map_type::iterator I = Map.find(&F); - if (I != Map.end()) + finfo_map_type::iterator I = FInfoMap.find(&F); + if (I != FInfoMap.end()) return *I->second; - - Collector *C = getOrCreateCollector(F.getParent(), F.getCollector()); - CollectorMetadata *MD = C->insertFunctionMetadata(F); - Map[&F] = MD; - return *MD; + + GCStrategy *S = getOrCreateStrategy(F.getParent(), F.getGC()); + GCFunctionInfo *GFI = S->insertFunctionInfo(F); + FInfoMap[&F] = GFI; + return *GFI; } -void CollectorModuleMetadata::clear() { - Map.clear(); - NameMap.clear(); +void GCModuleInfo::clear() { + FInfoMap.clear(); + StrategyMap.clear(); for (iterator I = begin(), E = end(); I != E; ++I) delete *I; - Collectors.clear(); + StrategyList.clear(); } // ----------------------------------------------------------------------------- char Printer::ID = 0; -FunctionPass *llvm::createCollectorMetadataPrinter(std::ostream &OS) { +FunctionPass *llvm::createGCInfoPrinter(std::ostream &OS) { return new Printer(OS); } @@ -139,7 +138,7 @@ const char *Printer::getPassName() const { void Printer::getAnalysisUsage(AnalysisUsage &AU) const { FunctionPass::getAnalysisUsage(AU); AU.setPreservesAll(); - AU.addRequired(); + AU.addRequired(); } static const char *DescKind(GC::PointKind Kind) { @@ -153,23 +152,22 @@ static const char *DescKind(GC::PointKind Kind) { } bool Printer::runOnFunction(Function &F) { - if (F.hasCollector()) { - CollectorMetadata *FD = &getAnalysis().get(F); + if (!F.hasGC()) { + GCFunctionInfo *FD = &getAnalysis().getFunctionInfo(F); OS << "GC roots for " << FD->getFunction().getNameStart() << ":\n"; - for (CollectorMetadata::roots_iterator RI = FD->roots_begin(), - RE = FD->roots_end(); - RI != RE; ++RI) + for (GCFunctionInfo::roots_iterator RI = FD->roots_begin(), + RE = FD->roots_end(); RI != RE; ++RI) OS << "\t" << RI->Num << "\t" << RI->StackOffset << "[sp]\n"; OS << "GC safe points for " << FD->getFunction().getNameStart() << ":\n"; - for (CollectorMetadata::iterator PI = FD->begin(), - PE = FD->end(); PI != PE; ++PI) { + for (GCFunctionInfo::iterator PI = FD->begin(), + PE = FD->end(); PI != PE; ++PI) { OS << "\tlabel " << PI->Num << ": " << DescKind(PI->Kind) << ", live = {"; - for (CollectorMetadata::live_iterator RI = FD->live_begin(PI), - RE = FD->live_end(PI);;) { + for (GCFunctionInfo::live_iterator RI = FD->live_begin(PI), + RE = FD->live_end(PI);;) { OS << " " << RI->Num; if (++RI == RE) break; @@ -187,7 +185,7 @@ bool Printer::runOnFunction(Function &F) { char Deleter::ID = 0; -FunctionPass *llvm::createCollectorMetadataDeleter() { +FunctionPass *llvm::createGCInfoDeleter() { return new Deleter(); } @@ -199,7 +197,7 @@ const char *Deleter::getPassName() const { void Deleter::getAnalysisUsage(AnalysisUsage &AU) const { AU.setPreservesAll(); - AU.addRequired(); + AU.addRequired(); } bool Deleter::runOnFunction(Function &MF) { @@ -207,8 +205,8 @@ bool Deleter::runOnFunction(Function &MF) { } bool Deleter::doFinalization(Module &M) { - CollectorModuleMetadata *CMM = getAnalysisToUpdate(); - assert(CMM && "Deleter didn't require CollectorModuleMetadata?!"); - CMM->clear(); + GCModuleInfo *GMI = getAnalysisToUpdate(); + assert(GMI && "Deleter didn't require GCModuleInfo?!"); + GMI->clear(); return false; } diff --git a/lib/CodeGen/GCMetadataPrinter.cpp b/lib/CodeGen/GCMetadataPrinter.cpp index b16d873520..07ec0bd035 100644 --- a/lib/CodeGen/GCMetadataPrinter.cpp +++ b/lib/CodeGen/GCMetadataPrinter.cpp @@ -1,4 +1,4 @@ -//===-- Collector.cpp - Garbage collection infrastructure -----------------===// +//===-- GCMetadataPrinter.cpp - Garbage collection infrastructure ---------===// // // The LLVM Compiler Infrastructure // @@ -7,15 +7,25 @@ // //===----------------------------------------------------------------------===// // -// This file implements target- and collector-independent garbage collection -// infrastructure. +// This file implements the abstract base class GCMetadataPrinter. // //===----------------------------------------------------------------------===// -#include "llvm/CodeGen/GCStrategy.h" +#include "llvm/CodeGen/GCMetadataPrinter.h" using namespace llvm; +// ----------------------------------------------------------------------------- + +template<> GCMetadataPrinterRegistry::node *GCMetadataPrinterRegistry::Head = 0; +template<> GCMetadataPrinterRegistry::node *GCMetadataPrinterRegistry::Tail = 0; +template<> GCMetadataPrinterRegistry::listener * +GCMetadataPrinterRegistry::ListenerHead = 0; +template<> GCMetadataPrinterRegistry::listener * +GCMetadataPrinterRegistry::ListenerTail = 0; + +// ----------------------------------------------------------------------------- + GCMetadataPrinter::GCMetadataPrinter() { } GCMetadataPrinter::~GCMetadataPrinter() { } diff --git a/lib/CodeGen/GCStrategy.cpp b/lib/CodeGen/GCStrategy.cpp index f5cb9ab631..2666775996 100644 --- a/lib/CodeGen/GCStrategy.cpp +++ b/lib/CodeGen/GCStrategy.cpp @@ -1,4 +1,4 @@ -//===-- Collector.cpp - Garbage collection infrastructure -----------------===// +//===-- GCStrategy.cpp - Garbage collection infrastructure -----------------===// // // The LLVM Compiler Infrastructure // @@ -10,6 +10,9 @@ // This file implements target- and collector-independent garbage collection // infrastructure. // +// MachineCodeAnalysis identifies the GC safe points in the machine code. Roots +// are identified in SelectionDAGISel. +// //===----------------------------------------------------------------------===// #include "llvm/CodeGen/GCStrategy.h" @@ -31,13 +34,13 @@ namespace { /// LowerIntrinsics - This pass rewrites calls to the llvm.gcread or /// llvm.gcwrite intrinsics, replacing them with simple loads and stores as - /// directed by the Collector. It also performs automatic root initialization + /// directed by the GCStrategy. It also performs automatic root initialization /// and custom intrinsic lowering. class VISIBILITY_HIDDEN LowerIntrinsics : public FunctionPass { - static bool NeedsDefaultLoweringPass(const Collector &C); - static bool NeedsCustomLoweringPass(const Collector &C); + static bool NeedsDefaultLoweringPass(const GCStrategy &C); + static bool NeedsCustomLoweringPass(const GCStrategy &C); static bool CouldBecomeSafePoint(Instruction *I); - bool PerformDefaultLowering(Function &F, Collector &Coll); + bool PerformDefaultLowering(Function &F, GCStrategy &Coll); static bool InsertRootInitializers(Function &F, AllocaInst **Roots, unsigned Count); @@ -56,10 +59,10 @@ namespace { /// MachineCodeAnalysis - This is a target-independent pass over the machine /// function representation to identify safe points for the garbage collector /// in the machine code. It inserts labels at safe points and populates a - /// CollectorMetadata record for each function. + /// GCMetadata record for each function. class VISIBILITY_HIDDEN MachineCodeAnalysis : public MachineFunctionPass { const TargetMachine *TM; - CollectorMetadata *MD; + GCFunctionInfo *FI; MachineModuleInfo *MMI; const TargetInstrInfo *TII; MachineFrameInfo *MFI; @@ -85,7 +88,14 @@ namespace { // ----------------------------------------------------------------------------- -Collector::Collector() : +template<> GCRegistry::node *GCRegistry::Head = 0; +template<> GCRegistry::node *GCRegistry::Tail = 0; +template<> GCRegistry::listener *GCRegistry::ListenerHead = 0; +template<> GCRegistry::listener *GCRegistry::ListenerTail = 0; + +// ----------------------------------------------------------------------------- + +GCStrategy::GCStrategy() : NeededSafePoints(0), CustomReadBarriers(false), CustomWriteBarriers(false), @@ -94,26 +104,26 @@ Collector::Collector() : UsesMetadata(false) {} -Collector::~Collector() { +GCStrategy::~GCStrategy() { for (iterator I = begin(), E = end(); I != E; ++I) delete *I; Functions.clear(); } -bool Collector::initializeCustomLowering(Module &M) { return false; } +bool GCStrategy::initializeCustomLowering(Module &M) { return false; } -bool Collector::performCustomLowering(Function &F) { +bool GCStrategy::performCustomLowering(Function &F) { cerr << "gc " << getName() << " must override performCustomLowering.\n"; abort(); return 0; } - -CollectorMetadata *Collector::insertFunctionMetadata(const Function &F) { - CollectorMetadata *CM = new CollectorMetadata(F, *this); - Functions.push_back(CM); - return CM; -} + +GCFunctionInfo *GCStrategy::insertFunctionInfo(const Function &F) { + GCFunctionInfo *FI = new GCFunctionInfo(F, *this); + Functions.push_back(FI); + return FI; +} // ----------------------------------------------------------------------------- @@ -132,7 +142,7 @@ const char *LowerIntrinsics::getPassName() const { void LowerIntrinsics::getAnalysisUsage(AnalysisUsage &AU) const { FunctionPass::getAnalysisUsage(AU); - AU.addRequired(); + AU.addRequired(); } /// doInitialization - If this module uses the GC intrinsics, find them now. @@ -141,15 +151,14 @@ bool LowerIntrinsics::doInitialization(Module &M) { // work against the entire module. But this cannot be done at // runFunction time (initializeCustomLowering likely needs to change // the module). - CollectorModuleMetadata *CMM = getAnalysisToUpdate(); - assert(CMM && "LowerIntrinsics didn't require CollectorModuleMetadata!?"); + GCModuleInfo *MI = getAnalysisToUpdate(); + assert(MI && "LowerIntrinsics didn't require GCModuleInfo!?"); for (Module::iterator I = M.begin(), E = M.end(); I != E; ++I) - if (!I->isDeclaration() && I->hasCollector()) - CMM->get(*I); // Instantiate the Collector. + if (!I->isDeclaration() && I->hasGC()) + MI->getFunctionInfo(*I); // Instantiate the GC strategy. bool MadeChange = false; - for (CollectorModuleMetadata::iterator I = CMM->begin(), - E = CMM->end(); I != E; ++I) + for (GCModuleInfo::iterator I = MI->begin(), E = MI->end(); I != E; ++I) if (NeedsCustomLoweringPass(**I)) if ((*I)->initializeCustomLowering(M)) MadeChange = true; @@ -185,7 +194,7 @@ bool LowerIntrinsics::InsertRootInitializers(Function &F, AllocaInst **Roots, return MadeChange; } -bool LowerIntrinsics::NeedsDefaultLoweringPass(const Collector &C) { +bool LowerIntrinsics::NeedsDefaultLoweringPass(const GCStrategy &C) { // Default lowering is necessary only if read or write barriers have a default // action. The default for roots is no action. return !C.customWriteBarrier() @@ -193,7 +202,7 @@ bool LowerIntrinsics::NeedsDefaultLoweringPass(const Collector &C) { || C.initializeRoots(); } -bool LowerIntrinsics::NeedsCustomLoweringPass(const Collector &C) { +bool LowerIntrinsics::NeedsCustomLoweringPass(const GCStrategy &C) { // Custom lowering is only necessary if enabled for some action. return C.customWriteBarrier() || C.customReadBarrier() @@ -232,26 +241,27 @@ bool LowerIntrinsics::CouldBecomeSafePoint(Instruction *I) { /// Leave gcroot intrinsics; the code generator needs to see those. bool LowerIntrinsics::runOnFunction(Function &F) { // Quick exit for functions that do not use GC. - if (!F.hasCollector()) return false; + if (!F.hasGC()) + return false; - CollectorMetadata &MD = getAnalysis().get(F); - Collector &Coll = MD.getCollector(); + GCFunctionInfo &FI = getAnalysis().getFunctionInfo(F); + GCStrategy &S = FI.getStrategy(); bool MadeChange = false; - if (NeedsDefaultLoweringPass(Coll)) - MadeChange |= PerformDefaultLowering(F, Coll); + if (NeedsDefaultLoweringPass(S)) + MadeChange |= PerformDefaultLowering(F, S); - if (NeedsCustomLoweringPass(Coll)) - MadeChange |= Coll.performCustomLowering(F); + if (NeedsCustomLoweringPass(S)) + MadeChange |= S.performCustomLowering(F); return MadeChange; } -bool LowerIntrinsics::PerformDefaultLowering(Function &F, Collector &Coll) { - bool LowerWr = !Coll.customWriteBarrier(); - bool LowerRd = !Coll.customReadBarrier(); - bool InitRoots = Coll.initializeRoots(); +bool LowerIntrinsics::PerformDefaultLowering(Function &F, GCStrategy &S) { + bool LowerWr = !S.customWriteBarrier(); + bool LowerRd = !S.customReadBarrier(); + bool InitRoots = S.initializeRoots(); SmallVector Roots; @@ -320,7 +330,7 @@ void MachineCodeAnalysis::getAnalysisUsage(AnalysisUsage &AU) const { MachineFunctionPass::getAnalysisUsage(AU); AU.setPreservesAll(); AU.addRequired(); - AU.addRequired(); + AU.addRequired(); } unsigned MachineCodeAnalysis::InsertLabel(MachineBasicBlock &MBB, @@ -336,11 +346,11 @@ void MachineCodeAnalysis::VisitCallPoint(MachineBasicBlock::iterator CI) { MachineBasicBlock::iterator RAI = CI; ++RAI; - if (MD->getCollector().needsSafePoint(GC::PreCall)) - MD->addSafePoint(GC::PreCall, InsertLabel(*CI->getParent(), CI)); + if (FI->getStrategy().needsSafePoint(GC::PreCall)) + FI->addSafePoint(GC::PreCall, InsertLabel(*CI->getParent(), CI)); - if (MD->getCollector().needsSafePoint(GC::PostCall)) - MD->addSafePoint(GC::PostCall, InsertLabel(*CI->getParent(), RAI)); + if (FI->getStrategy().needsSafePoint(GC::PostCall)) + FI->addSafePoint(GC::PostCall, InsertLabel(*CI->getParent(), RAI)); } void MachineCodeAnalysis::FindSafePoints(MachineFunction &MF) { @@ -357,18 +367,19 @@ void MachineCodeAnalysis::FindStackOffsets(MachineFunction &MF) { uint64_t OffsetAdjustment = MFI->getOffsetAdjustment(); uint64_t OffsetOfLocalArea = TM->getFrameInfo()->getOffsetOfLocalArea(); - for (CollectorMetadata::roots_iterator RI = MD->roots_begin(), - RE = MD->roots_end(); RI != RE; ++RI) + for (GCFunctionInfo::roots_iterator RI = FI->roots_begin(), + RE = FI->roots_end(); RI != RE; ++RI) RI->StackOffset = MFI->getObjectOffset(RI->Num) + StackSize - OffsetOfLocalArea + OffsetAdjustment; } bool MachineCodeAnalysis::runOnMachineFunction(MachineFunction &MF) { // Quick exit for functions that do not use GC. - if (!MF.getFunction()->hasCollector()) return false; + if (!MF.getFunction()->hasGC()) + return false; - MD = &getAnalysis().get(*MF.getFunction()); - if (!MD->getCollector().needsSafePoints()) + FI = &getAnalysis().getFunctionInfo(*MF.getFunction()); + if (!FI->getStrategy().needsSafePoints()) return false; TM = &MF.getTarget(); @@ -377,7 +388,7 @@ bool MachineCodeAnalysis::runOnMachineFunction(MachineFunction &MF) { MFI = MF.getFrameInfo(); // Find the size of the stack frame. - MD->setFrameSize(MFI->getStackSize()); + FI->setFrameSize(MFI->getStackSize()); // Find all safe points. FindSafePoints(MF); diff --git a/lib/CodeGen/GCs.cpp b/lib/CodeGen/GCs.cpp deleted file mode 100644 index 124725358e..0000000000 --- a/lib/CodeGen/GCs.cpp +++ /dev/null @@ -1,28 +0,0 @@ -//===-- Collectors.cpp - Garbage collector registry -----------------------===// -// -// The LLVM Compiler Infrastructure -// -// This file is distributed under the University of Illinois Open Source -// License. See LICENSE.TXT for details. -// -//===----------------------------------------------------------------------===// -// -// This file defines the static data members of the CollectorRegistry class. -// -//===----------------------------------------------------------------------===// - -#include "llvm/CodeGen/GCs.h" - -using namespace llvm; - -template<> CollectorRegistry::node *CollectorRegistry::Head = 0; -template<> CollectorRegistry::node *CollectorRegistry::Tail = 0; -template<> CollectorRegistry::listener *CollectorRegistry::ListenerHead = 0; -template<> CollectorRegistry::listener *CollectorRegistry::ListenerTail = 0; - -template<> GCMetadataPrinterRegistry::node *GCMetadataPrinterRegistry::Head = 0; -template<> GCMetadataPrinterRegistry::node *GCMetadataPrinterRegistry::Tail = 0; -template<> GCMetadataPrinterRegistry::listener * -GCMetadataPrinterRegistry::ListenerHead = 0; -template<> GCMetadataPrinterRegistry::listener * -GCMetadataPrinterRegistry::ListenerTail = 0; diff --git a/lib/CodeGen/LLVMTargetMachine.cpp b/lib/CodeGen/LLVMTargetMachine.cpp index d420ffb7d9..938e1ae9cc 100644 --- a/lib/CodeGen/LLVMTargetMachine.cpp +++ b/lib/CodeGen/LLVMTargetMachine.cpp @@ -133,7 +133,7 @@ LLVMTargetMachine::addPassesToEmitFile(PassManagerBase &PM, PM.add(createMachineFunctionPrinterPass(cerr)); if (PrintGCInfo) - PM.add(createCollectorMetadataPrinter(*cerr)); + PM.add(createGCInfoPrinter(*cerr)); // Fold redundant debug labels. PM.add(createDebugLabelFoldingPass()); @@ -173,7 +173,7 @@ bool LLVMTargetMachine::addPassesToEmitFileFinish(PassManagerBase &PM, if (MCE) addSimpleCodeEmitter(PM, Fast, PrintEmittedAsm, *MCE); - PM.add(createCollectorMetadataDeleter()); + PM.add(createGCInfoDeleter()); // Delete machine code for this function PM.add(createMachineCodeDeleter()); @@ -274,14 +274,14 @@ bool LLVMTargetMachine::addPassesToEmitMachineCode(PassManagerBase &PM, PM.add(createMachineFunctionPrinterPass(cerr)); if (PrintGCInfo) - PM.add(createCollectorMetadataPrinter(*cerr)); + PM.add(createGCInfoPrinter(*cerr)); if (addPreEmitPass(PM, Fast) && PrintMachineCode) PM.add(createMachineFunctionPrinterPass(cerr)); addCodeEmitter(PM, Fast, PrintEmittedAsm, MCE); - PM.add(createCollectorMetadataDeleter()); + PM.add(createGCInfoDeleter()); // Delete machine code for this function PM.add(createMachineCodeDeleter()); diff --git a/lib/CodeGen/OcamlGC.cpp b/lib/CodeGen/OcamlGC.cpp index 88499cbd66..0b90444406 100644 --- a/lib/CodeGen/OcamlGC.cpp +++ b/lib/CodeGen/OcamlGC.cpp @@ -1,4 +1,4 @@ -//===-- OcamlCollector.cpp - Ocaml frametable emitter ---------------------===// +//===-- OcamlGC.cpp - Ocaml frametable GC strategy ------------------------===// // // The LLVM Compiler Infrastructure // @@ -9,38 +9,29 @@ // // This file implements lowering for the llvm.gc* intrinsics compatible with // Objective Caml 3.10.0, which uses a liveness-accurate static stack map. +// +// The frametable emitter is in OcamlGCPrinter.cpp. // //===----------------------------------------------------------------------===// #include "llvm/CodeGen/GCs.h" -#include "llvm/CodeGen/AsmPrinter.h" #include "llvm/CodeGen/GCStrategy.h" -#include "llvm/Module.h" -#include "llvm/Target/TargetAsmInfo.h" -#include "llvm/Target/TargetData.h" -#include "llvm/Target/TargetMachine.h" using namespace llvm; namespace { - - class VISIBILITY_HIDDEN OcamlCollector : public Collector { + class VISIBILITY_HIDDEN OcamlGC : public GCStrategy { public: - OcamlCollector(); + OcamlGC(); }; - } -static CollectorRegistry::Add -X("ocaml", "ocaml 3.10-compatible collector"); - -// ----------------------------------------------------------------------------- +static GCRegistry::Add +X("ocaml", "ocaml 3.10-compatible GC"); -Collector *llvm::createOcamlCollector() { - return new OcamlCollector(); -} +void llvm::linkOcamlGC() { } -OcamlCollector::OcamlCollector() { +OcamlGC::OcamlGC() { NeededSafePoints = 1 << GC::PostCall; UsesMetadata = true; } diff --git a/lib/CodeGen/SelectionDAG/SelectionDAGISel.cpp b/lib/CodeGen/SelectionDAG/SelectionDAGISel.cpp index 012e7d0992..f4e31f727e 100644 --- a/lib/CodeGen/SelectionDAG/SelectionDAGISel.cpp +++ b/lib/CodeGen/SelectionDAG/SelectionDAGISel.cpp @@ -27,6 +27,7 @@ #include "llvm/IntrinsicInst.h" #include "llvm/ParameterAttributes.h" #include "llvm/CodeGen/GCStrategy.h" +#include "llvm/CodeGen/GCMetadata.h" #include "llvm/CodeGen/MachineFunction.h" #include "llvm/CodeGen/MachineFrameInfo.h" #include "llvm/CodeGen/MachineInstrBuilder.h" @@ -601,15 +602,15 @@ public: /// FunctionLoweringInfo &FuncInfo; - /// GCI - Garbage collection metadata for the function. - CollectorMetadata *GCI; + /// GFI - Garbage collection metadata for the function. + GCFunctionInfo *GFI; SelectionDAGLowering(SelectionDAG &dag, TargetLowering &tli, AliasAnalysis &aa, FunctionLoweringInfo &funcinfo, - CollectorMetadata *gci) + GCFunctionInfo *gfi) : TLI(tli), DAG(dag), TD(DAG.getTarget().getTargetData()), AA(aa), - FuncInfo(funcinfo), GCI(gci) { + FuncInfo(funcinfo), GFI(gfi) { } /// getRoot - Return the current virtual root of the Selection DAG, @@ -3485,18 +3486,18 @@ SelectionDAGLowering::visitIntrinsicCall(CallInst &I, unsigned Intrinsic) { } case Intrinsic::gcroot: - if (GCI) { + if (GFI) { Value *Alloca = I.getOperand(1); Constant *TypeMap = cast(I.getOperand(2)); FrameIndexSDNode *FI = cast(getValue(Alloca).Val); - GCI->addStackRoot(FI->getIndex(), TypeMap); + GFI->addStackRoot(FI->getIndex(), TypeMap); } return 0; case Intrinsic::gcread: case Intrinsic::gcwrite: - assert(0 && "Collector failed to lower gcread/gcwrite intrinsics!"); + assert(0 && "GC failed to lower gcread/gcwrite intrinsics!"); return 0; case Intrinsic::flt_rounds: { @@ -4878,7 +4879,7 @@ unsigned SelectionDAGISel::MakeReg(MVT VT) { void SelectionDAGISel::getAnalysisUsage(AnalysisUsage &AU) const { AU.addRequired(); - AU.addRequired(); + AU.addRequired(); AU.setPreservesAll(); } @@ -4887,10 +4888,10 @@ bool SelectionDAGISel::runOnFunction(Function &Fn) { AA = &getAnalysis(); MachineFunction &MF = MachineFunction::construct(&Fn, TLI.getTargetMachine()); - if (MF.getFunction()->hasCollector()) - GCI = &getAnalysis().get(*MF.getFunction()); + if (MF.getFunction()->hasGC()) + GFI = &getAnalysis().getFunctionInfo(*MF.getFunction()); else - GCI = 0; + GFI = 0; RegInfo = &MF.getRegInfo(); DOUT << "\n\n\n=== " << Fn.getName() << "\n"; @@ -5089,7 +5090,7 @@ static void CheckDAGForTailCallsAndFixThem(SelectionDAG &DAG, void SelectionDAGISel::BuildSelectionDAG(SelectionDAG &DAG, BasicBlock *LLVMBB, std::vector > &PHINodesToUpdate, FunctionLoweringInfo &FuncInfo) { - SelectionDAGLowering SDL(DAG, TLI, *AA, FuncInfo, GCI); + SelectionDAGLowering SDL(DAG, TLI, *AA, FuncInfo, GFI); // Lower any arguments needed in this block if this is the entry block. if (LLVMBB == &LLVMBB->getParent()->getEntryBlock()) @@ -5504,7 +5505,7 @@ SelectionDAGISel::FinishBasicBlock(BasicBlock *LLVMBB, MachineFunction &MF, getAnalysisToUpdate(), NodeAllocator); CurDAG = &HSDAG; - SelectionDAGLowering HSDL(HSDAG, TLI, *AA, FuncInfo, GCI); + SelectionDAGLowering HSDL(HSDAG, TLI, *AA, FuncInfo, GFI); // Set the current basic block to the mbb we wish to insert the code into BB = BitTestCases[i].Parent; HSDL.setCurrentBasicBlock(BB); @@ -5519,7 +5520,7 @@ SelectionDAGISel::FinishBasicBlock(BasicBlock *LLVMBB, MachineFunction &MF, getAnalysisToUpdate(), NodeAllocator); CurDAG = &BSDAG; - SelectionDAGLowering BSDL(BSDAG, TLI, *AA, FuncInfo, GCI); + SelectionDAGLowering BSDL(BSDAG, TLI, *AA, FuncInfo, GFI); // Set the current basic block to the mbb we wish to insert the code into BB = BitTestCases[i].Cases[j].ThisBB; BSDL.setCurrentBasicBlock(BB); @@ -5578,7 +5579,7 @@ SelectionDAGISel::FinishBasicBlock(BasicBlock *LLVMBB, MachineFunction &MF, getAnalysisToUpdate(), NodeAllocator); CurDAG = &HSDAG; - SelectionDAGLowering HSDL(HSDAG, TLI, *AA, FuncInfo, GCI); + SelectionDAGLowering HSDL(HSDAG, TLI, *AA, FuncInfo, GFI); // Set the current basic block to the mbb we wish to insert the code into BB = JTCases[i].first.HeaderBB; HSDL.setCurrentBasicBlock(BB); @@ -5592,7 +5593,7 @@ SelectionDAGISel::FinishBasicBlock(BasicBlock *LLVMBB, MachineFunction &MF, getAnalysisToUpdate(), NodeAllocator); CurDAG = &JSDAG; - SelectionDAGLowering JSDL(JSDAG, TLI, *AA, FuncInfo, GCI); + SelectionDAGLowering JSDL(JSDAG, TLI, *AA, FuncInfo, GFI); // Set the current basic block to the mbb we wish to insert the code into BB = JTCases[i].second.MBB; JSDL.setCurrentBasicBlock(BB); @@ -5642,7 +5643,7 @@ SelectionDAGISel::FinishBasicBlock(BasicBlock *LLVMBB, MachineFunction &MF, getAnalysisToUpdate(), NodeAllocator); CurDAG = &SDAG; - SelectionDAGLowering SDL(SDAG, TLI, *AA, FuncInfo, GCI); + SelectionDAGLowering SDL(SDAG, TLI, *AA, FuncInfo, GFI); // Set the current basic block to the mbb we wish to insert the code into BB = SwitchCases[i].ThisBB; diff --git a/lib/CodeGen/ShadowStackGC.cpp b/lib/CodeGen/ShadowStackGC.cpp index 850c00542c..cf0e6ddbae 100644 --- a/lib/CodeGen/ShadowStackGC.cpp +++ b/lib/CodeGen/ShadowStackGC.cpp @@ -1,4 +1,4 @@ -//===-- ShadowStackCollector.cpp - GC support for uncooperative targets ---===// +//===-- ShadowStackGC.cpp - GC support for uncooperative targets ----------===// // // The LLVM Compiler Infrastructure // @@ -9,7 +9,7 @@ // // This file implements lowering for the llvm.gc* intrinsics for targets that do // not natively support them (which includes the C backend). Note that the code -// generated is not quite as efficient as collectors which generate stack maps +// generated is not quite as efficient as algorithms which generate stack maps // to identify roots. // // This pass implements the code transformation described in this paper: @@ -17,7 +17,7 @@ // Fergus Henderson, ISMM, 2002 // // In runtime/GC/SemiSpace.cpp is a prototype runtime which is compatible with -// this collector. +// ShadowStackGC. // // In order to support this particular transformation, all stack roots are // coallocated in the stack. This allows a fully target-independent stack map @@ -37,7 +37,7 @@ using namespace llvm; namespace { - class VISIBILITY_HIDDEN ShadowStackCollector : public Collector { + class VISIBILITY_HIDDEN ShadowStackGC : public GCStrategy { /// RootChain - This is the global linked-list that contains the chain of GC /// roots. GlobalVariable *Head; @@ -51,7 +51,7 @@ namespace { std::vector > Roots; public: - ShadowStackCollector(); + ShadowStackGC(); bool initializeCustomLowering(Module &M); bool performCustomLowering(Function &F); @@ -69,9 +69,8 @@ namespace { } -static CollectorRegistry::Add -Y("shadow-stack", - "Very portable collector for uncooperative code generators"); +static GCRegistry::Add +X("shadow-stack", "Very portable GC for uncooperative code generators"); namespace { /// EscapeEnumerator - This is a little algorithm to find all escape points @@ -173,21 +172,18 @@ namespace { } } }; - } // ----------------------------------------------------------------------------- -Collector *llvm::createShadowStackCollector() { - return new ShadowStackCollector(); -} +void llvm::linkShadowStackGC() { } -ShadowStackCollector::ShadowStackCollector() : Head(0), StackEntryTy(0) { +ShadowStackGC::ShadowStackGC() : Head(0), StackEntryTy(0) { InitRoots = true; CustomRoots = true; } -Constant *ShadowStackCollector::GetFrameMap(Function &F) { +Constant *ShadowStackGC::GetFrameMap(Function &F) { // doInitialization creates the abstract type of this value. Type *VoidPtr = PointerType::getUnqual(Type::Int8Ty); @@ -242,7 +238,7 @@ Constant *ShadowStackCollector::GetFrameMap(Function &F) { return ConstantExpr::getGetElementPtr(GV, GEPIndices, 2); } -const Type* ShadowStackCollector::GetConcreteStackEntryType(Function &F) { +const Type* ShadowStackGC::GetConcreteStackEntryType(Function &F) { // doInitialization creates the generic version of this type. std::vector EltTys; EltTys.push_back(StackEntryTy); @@ -259,7 +255,7 @@ const Type* ShadowStackCollector::GetConcreteStackEntryType(Function &F) { /// doInitialization - If this module uses the GC intrinsics, find them now. If /// not, exit fast. -bool ShadowStackCollector::initializeCustomLowering(Module &M) { +bool ShadowStackGC::initializeCustomLowering(Module &M) { // struct FrameMap { // int32_t NumRoots; // Number of roots in stack frame. // int32_t NumMeta; // Number of metadata descriptors. May be < NumRoots. @@ -307,13 +303,13 @@ bool ShadowStackCollector::initializeCustomLowering(Module &M) { return true; } -bool ShadowStackCollector::IsNullValue(Value *V) { +bool ShadowStackGC::IsNullValue(Value *V) { if (Constant *C = dyn_cast(V)) return C->isNullValue(); return false; } -void ShadowStackCollector::CollectRoots(Function &F) { +void ShadowStackGC::CollectRoots(Function &F) { // FIXME: Account for original alignment. Could fragment the root array. // Approach 1: Null initialize empty slots at runtime. Yuck. // Approach 2: Emit a map of the array instead of just a count. @@ -341,8 +337,8 @@ void ShadowStackCollector::CollectRoots(Function &F) { } GetElementPtrInst * -ShadowStackCollector::CreateGEP(IRBuilder<> &B, Value *BasePtr, - int Idx, int Idx2, const char *Name) { +ShadowStackGC::CreateGEP(IRBuilder<> &B, Value *BasePtr, + int Idx, int Idx2, const char *Name) { Value *Indices[] = { ConstantInt::get(Type::Int32Ty, 0), ConstantInt::get(Type::Int32Ty, Idx), ConstantInt::get(Type::Int32Ty, Idx2) }; @@ -354,8 +350,8 @@ ShadowStackCollector::CreateGEP(IRBuilder<> &B, Value *BasePtr, } GetElementPtrInst * -ShadowStackCollector::CreateGEP(IRBuilder<> &B, Value *BasePtr, - int Idx, const char *Name) { +ShadowStackGC::CreateGEP(IRBuilder<> &B, Value *BasePtr, + int Idx, const char *Name) { Value *Indices[] = { ConstantInt::get(Type::Int32Ty, 0), ConstantInt::get(Type::Int32Ty, Idx) }; Value *Val = B.CreateGEP(BasePtr, Indices, Indices + 2, Name); @@ -366,7 +362,7 @@ ShadowStackCollector::CreateGEP(IRBuilder<> &B, Value *BasePtr, } /// runOnFunction - Insert code to maintain the shadow stack. -bool ShadowStackCollector::performCustomLowering(Function &F) { +bool ShadowStackGC::performCustomLowering(Function &F) { // Find calls to llvm.gcroot. CollectRoots(F); @@ -405,9 +401,10 @@ bool ShadowStackCollector::performCustomLowering(Function &F) { OriginalAlloca->replaceAllUsesWith(SlotPtr); } - // Move past the original stores inserted by Collector::InitRoots. This isn't - // really necessary (the collector would never see the intermediate state), - // but it's nicer not to push the half-initialized entry onto the stack. + // Move past the original stores inserted by GCStrategy::InitRoots. This isn't + // really necessary (the collector would never see the intermediate state at + // runtime), but it's nicer not to push the half-initialized entry onto the + // shadow stack. while (isa(IP)) ++IP; AtEntry.SetInsertPoint(IP->getParent(), IP); -- cgit v1.2.3