Home | History | Annotate | Line # | Download | only in CodeGen 
      1 //===-- GCMetadata.cpp - Garbage collector metadata -----------------------===//
      2 //
      3 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
      4 // See https://llvm.org/LICENSE.txt for license information.
      5 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
      6 //
      7 //===----------------------------------------------------------------------===//
      8 //
      9 // This file implements the GCFunctionInfo class and GCModuleInfo pass.
     10 //
     11 //===----------------------------------------------------------------------===//
     12 
     13 #include "llvm/CodeGen/GCMetadata.h"
     14 #include "llvm/ADT/STLExtras.h"
     15 #include "llvm/ADT/StringExtras.h"
     16 #include "llvm/CodeGen/Passes.h"
     17 #include "llvm/IR/Function.h"
     18 #include "llvm/InitializePasses.h"
     19 #include "llvm/MC/MCSymbol.h"
     20 #include "llvm/Pass.h"
     21 #include "llvm/Support/ErrorHandling.h"
     22 #include "llvm/Support/raw_ostream.h"
     23 #include <algorithm>
     24 #include <cassert>
     25 #include <memory>
     26 #include <string>
     27 
     28 using namespace llvm;
     29 
     30 namespace {
     31 
     32 class Printer : public FunctionPass {
     33   static char ID;
     34 
     35   raw_ostream &OS;
     36 
     37 public:
     38   explicit Printer(raw_ostream &OS) : FunctionPass(ID), OS(OS) {}
     39 
     40   StringRef getPassName() const override;
     41   void getAnalysisUsage(AnalysisUsage &AU) const override;
     42 
     43   bool runOnFunction(Function &F) override;
     44   bool doFinalization(Module &M) override;
     45 };
     46 
     47 } // end anonymous namespace
     48 
     49 INITIALIZE_PASS(GCModuleInfo, "collector-metadata",
     50                 "Create Garbage Collector Module Metadata", false, false)
     51 
     52 // -----------------------------------------------------------------------------
     53 
     54 GCFunctionInfo::GCFunctionInfo(const Function &F, GCStrategy &S)
     55     : F(F), S(S), FrameSize(~0LL) {}
     56 
     57 GCFunctionInfo::~GCFunctionInfo() = default;
     58 
     59 // -----------------------------------------------------------------------------
     60 
     61 char GCModuleInfo::ID = 0;
     62 
     63 GCModuleInfo::GCModuleInfo() : ImmutablePass(ID) {
     64   initializeGCModuleInfoPass(*PassRegistry::getPassRegistry());
     65 }
     66 
     67 GCFunctionInfo &GCModuleInfo::getFunctionInfo(const Function &F) {
     68   assert(!F.isDeclaration() && "Can only get GCFunctionInfo for a definition!");
     69   assert(F.hasGC());
     70 
     71   finfo_map_type::iterator I = FInfoMap.find(&F);
     72   if (I != FInfoMap.end())
     73     return *I->second;
     74 
     75   GCStrategy *S = getGCStrategy(F.getGC());
     76   Functions.push_back(std::make_unique<GCFunctionInfo>(F, *S));
     77   GCFunctionInfo *GFI = Functions.back().get();
     78   FInfoMap[&F] = GFI;
     79   return *GFI;
     80 }
     81 
     82 void GCModuleInfo::clear() {
     83   Functions.clear();
     84   FInfoMap.clear();
     85   GCStrategyList.clear();
     86 }
     87 
     88 // -----------------------------------------------------------------------------
     89 
     90 char Printer::ID = 0;
     91 
     92 FunctionPass *llvm::createGCInfoPrinter(raw_ostream &OS) {
     93   return new Printer(OS);
     94 }
     95 
     96 StringRef Printer::getPassName() const {
     97   return "Print Garbage Collector Information";
     98 }
     99 
    100 void Printer::getAnalysisUsage(AnalysisUsage &AU) const {
    101   FunctionPass::getAnalysisUsage(AU);
    102   AU.setPreservesAll();
    103   AU.addRequired<GCModuleInfo>();
    104 }
    105 
    106 bool Printer::runOnFunction(Function &F) {
    107   if (F.hasGC())
    108     return false;
    109 
    110   GCFunctionInfo *FD = &getAnalysis<GCModuleInfo>().getFunctionInfo(F);
    111 
    112   OS << "GC roots for " << FD->getFunction().getName() << ":\n";
    113   for (GCFunctionInfo::roots_iterator RI = FD->roots_begin(),
    114                                       RE = FD->roots_end();
    115        RI != RE; ++RI)
    116     OS << "\t" << RI->Num << "\t" << RI->StackOffset << "[sp]\n";
    117 
    118   OS << "GC safe points for " << FD->getFunction().getName() << ":\n";
    119   for (GCFunctionInfo::iterator PI = FD->begin(), PE = FD->end(); PI != PE;
    120        ++PI) {
    121 
    122     OS << "\t" << PI->Label->getName() << ": " << "post-call"
    123        << ", live = {";
    124 
    125     ListSeparator LS(",");
    126     for (const GCRoot &R : make_range(FD->live_begin(PI), FD->live_end(PI)))
    127       OS << LS << " " << R.Num;
    128 
    129     OS << " }\n";
    130   }
    131 
    132   return false;
    133 }
    134 
    135 bool Printer::doFinalization(Module &M) {
    136   GCModuleInfo *GMI = getAnalysisIfAvailable<GCModuleInfo>();
    137   assert(GMI && "Printer didn't require GCModuleInfo?!");
    138   GMI->clear();
    139   return false;
    140 }
    141 
    142 GCStrategy *GCModuleInfo::getGCStrategy(const StringRef Name) {
    143   // TODO: Arguably, just doing a linear search would be faster for small N
    144   auto NMI = GCStrategyMap.find(Name);
    145   if (NMI != GCStrategyMap.end())
    146     return NMI->getValue();
    147 
    148   for (auto& Entry : GCRegistry::entries()) {
    149     if (Name == Entry.getName()) {
    150       std::unique_ptr<GCStrategy> S = Entry.instantiate();
    151       S->Name = std::string(Name);
    152       GCStrategyMap[Name] = S.get();
    153       GCStrategyList.push_back(std::move(S));
    154       return GCStrategyList.back().get();
    155     }
    156   }
    157 
    158   if (GCRegistry::begin() == GCRegistry::end()) {
    159     // In normal operation, the registry should not be empty.  There should
    160     // be the builtin GCs if nothing else.  The most likely scenario here is
    161     // that we got here without running the initializers used by the Registry
    162     // itself and it's registration mechanism.
    163     const std::string error = ("unsupported GC: " + Name).str() +
    164       " (did you remember to link and initialize the CodeGen library?)";
    165     report_fatal_error(error);
    166   } else
    167     report_fatal_error(std::string("unsupported GC: ") + Name);
    168 }
    169