TypeFinder: collect target types

[nhaehnle]

Summary

We will use this to output target type info when writing a module.

[Flakebi]

Looks good to me. One question/nit inline.

llvm/include/llvm/IR/TypeFinder.h

72

As a getter, this should probably return StructType * instead of a reference?

[nhaehnle]

Remove getStructType

llvm/include/llvm/IR/TypeFinder.h

72

It was a straight adjustment/rename of what used to be the operator[]; but it looks like that's unused? I'll double check and maybe just remove it.

[Flakebi]

Thanks!

llvm/include/llvm/IR/TypeFinder.h

 #include <cstddef>
 #include <vector>
 
 namespace llvm {
 
 class MDNode;
 class Module;
 class StructType;
+class TargetExtType;
 class Type;
 class Value;
 
 /// TypeFinder - Walk over a module, identifying all of the types that are
 /// used by the module.
 class TypeFinder {
   // To avoid walking constant expressions multiple times and other IR
   // objects, we keep several helper maps.
   DenseSet<const Value*> VisitedConstants;
   DenseSet<const MDNode *> VisitedMetadata;
   DenseSet<AttributeList> VisitedAttributes;
   DenseSet<Type*> VisitedTypes;
 
   std::vector<StructType*> StructTypes;
+  std::vector<TargetExtType *> TargetExtTypes;
   bool OnlyNamed = false;
 
 public:
   TypeFinder() = default;
 
   void run(const Module &M, bool onlyNamed);
   void clear();
 
-  using iterator = std::vector<StructType*>::iterator;
-  using const_iterator = std::vector<StructType*>::const_iterator;
+  using struct_iterator = std::vector<StructType *>::iterator;
+  using const_struct_iterator = std::vector<StructType *>::const_iterator;
 
-  iterator begin() { return StructTypes.begin(); }
-  iterator end() { return StructTypes.end(); }
+  struct_iterator structs_begin() { return StructTypes.begin(); }
+  struct_iterator structs_end() { return StructTypes.end(); }
 
-  const_iterator begin() const { return StructTypes.begin(); }
-  const_iterator end() const { return StructTypes.end(); }
+  const_struct_iterator structs_begin() const { return StructTypes.begin(); }
+  const_struct_iterator structs_end() const { return StructTypes.end(); }
 
-  bool empty() const { return StructTypes.empty(); }
-  size_t size() const { return StructTypes.size(); }
-  iterator erase(iterator I, iterator E) { return StructTypes.erase(I, E); }
+  iterator_range<struct_iterator> structs() {
+    return make_range(structs_begin(), structs_end());
+  }
+  iterator_range<const_struct_iterator> structs() const {
+    return make_range(structs_begin(), structs_end());
+  }
+
+  bool structs_empty() const { return StructTypes.empty(); }
+  size_t structs_size() const { return StructTypes.size(); }
+  struct_iterator structs_erase(struct_iterator I, struct_iterator E) {
+    return StructTypes.erase(I, E);
+  }
+
+  using const_target_ext_iterator =
+      std::vector<TargetExtType *>::const_iterator;
+
+  const_target_ext_iterator target_exts_begin() const {
+    return TargetExtTypes.begin();
+  }
+  const_target_ext_iterator target_exts_end() const {
+    return TargetExtTypes.end();
+  }
+
+  iterator_range<const_target_ext_iterator> target_exts() const {
+    return make_range(target_exts_begin(), target_exts_end());
+  }
 
-  StructType *&operator[](unsigned Idx) { return StructTypes[Idx]; }
+  bool target_exts_empty() const { return TargetExtTypes.empty(); }
 
   DenseSet<const MDNode *> &getVisitedMetadata() { return VisitedMetadata; }
 
 private:
   /// incorporateType - This method adds the type to the list of used
   /// structures if it's not in there already.
   void incorporateType(Type *Ty);
 

llvm/lib/IR/AsmWriter.cpp

 
 class TypePrinting {
 public:
   TypePrinting(const Module *M = nullptr) : DeferredM(M) {}
 
   TypePrinting(const TypePrinting &) = delete;
   TypePrinting &operator=(const TypePrinting &) = delete;
 
-  /// The named types that are used by the current module.
-  TypeFinder &getNamedTypes();
+  /// The type finder for the current module.
+  TypeFinder &getTypeFinder();
 
   /// The numbered types, number to type mapping.
   std::vector<StructType *> &getNumberedTypes();
 
   bool empty();
 
   void print(Type *Ty, raw_ostream &OS);
 
   void printStructBody(StructType *Ty, raw_ostream &OS);
 
 private:
   void incorporateTypes();
 
   /// A module to process lazily when needed. Set to nullptr as soon as used.
   const Module *DeferredM;
 
-  TypeFinder NamedTypes;
+  TypeFinder TF;
 
   // The numbered types, along with their value.
   DenseMap<StructType *, unsigned> Type2Number;
 
   std::vector<StructType *> NumberedTypes;
 };
 
 } // end anonymous namespace
 
-TypeFinder &TypePrinting::getNamedTypes() {
+TypeFinder &TypePrinting::getTypeFinder() {
   incorporateTypes();
-  return NamedTypes;
+  return TF;
 }
 
 std::vector<StructType *> &TypePrinting::getNumberedTypes() {
   incorporateTypes();
 
   // We know all the numbers that each type is used and we know that it is a
   // dense assignment. Convert the map to an index table, if it's not done
   // already (judging from the sizes):
   if (NumberedTypes.size() == Type2Number.size())
     return NumberedTypes;
 
   NumberedTypes.resize(Type2Number.size());
   for (const auto &P : Type2Number) {
     assert(P.second < NumberedTypes.size() && "Didn't get a dense numbering?");
     assert(!NumberedTypes[P.second] && "Didn't get a unique numbering?");
     NumberedTypes[P.second] = P.first;
   }
   return NumberedTypes;
 }
 
 bool TypePrinting::empty() {
   incorporateTypes();
-  return NamedTypes.empty() && Type2Number.empty();
+  return TF.structs_empty() && Type2Number.empty();
 }
 
 void TypePrinting::incorporateTypes() {
   if (!DeferredM)
     return;
 
-  NamedTypes.run(*DeferredM, false);
+  TF.run(*DeferredM, false);
   DeferredM = nullptr;
 
   // The list of struct types we got back includes all the struct types, split
   // the unnamed ones out to a numbering and remove the anonymous structs.
   unsigned NextNumber = 0;
 
-  std::vector<StructType *>::iterator NextToUse = NamedTypes.begin();
-  for (StructType *STy : NamedTypes) {
+  std::vector<StructType *>::iterator NextToUse = TF.structs_begin();
+  for (StructType *STy : TF.structs()) {
     // Ignore anonymous types.
     if (STy->isLiteral())
       continue;
 
     if (STy->getName().empty())
       Type2Number[STy] = NextNumber++;
     else
       *NextToUse++ = STy;
   }
 
-  NamedTypes.erase(NextToUse, NamedTypes.end());
+  TF.structs_erase(NextToUse, TF.structs_end());
 }
 
 /// Write the specified type to the specified raw_ostream, making use of type
 /// names or up references to shorten the type name where possible.
 void TypePrinting::print(Type *Ty, raw_ostream &OS) {
   switch (Ty->getTypeID()) {
   case Type::VoidTyID:      OS << "void"; return;
   case Type::HalfTyID:      OS << "half"; return;
for (unsigned I = 0, E = NumberedTypes.size(); I != E; ++I) {
     Out << '%' << I << " = type ";
 
     // Make sure we print out at least one level of the type structure, so
     // that we do not get %2 = type %2
     TypePrinter.printStructBody(NumberedTypes[I], Out);
     Out << '\n';
   }
 
-  auto &NamedTypes = TypePrinter.getNamedTypes();
-  for (StructType *NamedType : NamedTypes) {
+  auto &TF = TypePrinter.getTypeFinder();
+  for (StructType *NamedType : TF.structs()) {
     PrintLLVMName(Out, NamedType->getName(), LocalPrefix);
     Out << " = type ";
 
     // Make sure we print out at least one level of the type structure, so
     // that we do not get %FILE = type %FILE
     TypePrinter.printStructBody(NamedType, Out);
     Out << '\n';
   }

llvm/lib/IR/Module.cpp

std::vector<StructType *> Module::getIdentifiedStructTypes() const {
   // uses a type that is currently not visible to a TypeFinder, so ask
   // the materializer which types it created.
   if (Materializer)
     return Materializer->getIdentifiedStructTypes();
 
   std::vector<StructType *> Ret;
   TypeFinder SrcStructTypes;
   SrcStructTypes.run(*this, true);
-  Ret.assign(SrcStructTypes.begin(), SrcStructTypes.end());
+  Ret.assign(SrcStructTypes.structs_begin(), SrcStructTypes.structs_end());
   return Ret;
 }
 
 std::string Module::getUniqueIntrinsicName(StringRef BaseName, Intrinsic::ID Id,
                                            const FunctionType *Proto) {
   auto Encode = [&BaseName](unsigned Suffix) {
     return (Twine(BaseName) + "." + Twine(Suffix)).str();
   };

llvm/lib/IR/TypeFinder.cpp

if (!VisitedTypes.insert(Ty).second)
     return;
 
   SmallVector<Type *, 4> TypeWorklist;
   TypeWorklist.push_back(Ty);
   do {
     Ty = TypeWorklist.pop_back_val();
 
     // If this is a structure or opaque type, add a name for the type.
-    if (StructType *STy = dyn_cast<StructType>(Ty))
+    if (StructType *STy = dyn_cast<StructType>(Ty)) {
       if (!OnlyNamed || STy->hasName())
         StructTypes.push_back(STy);
+    } else if (TargetExtType *TTy = dyn_cast<TargetExtType>(Ty)) {
+      TargetExtTypes.push_back(TTy);
+    }
 
     // Add all unvisited subtypes to worklist for processing
     for (Type *SubTy : llvm::reverse(Ty->subtypes()))
       if (VisitedTypes.insert(SubTy).second)
         TypeWorklist.push_back(SubTy);
   } while (!TypeWorklist.empty());
 }
 

llvm/lib/Linker/IRMover.cpp

if (Ty->isOpaque())
     return OpaqueStructTypes.count(Ty);
   auto I = NonOpaqueStructTypes.find(Ty);
   return I == NonOpaqueStructTypes.end() ? false : *I == Ty;
 }
 
 IRMover::IRMover(Module &M) : Composite(M) {
   TypeFinder StructTypes;
   StructTypes.run(M, /* OnlyNamed */ false);
-  for (StructType *Ty : StructTypes) {
+  for (StructType *Ty : StructTypes.structs()) {
     if (Ty->isOpaque())
       IdentifiedStructTypes.addOpaque(Ty);
     else
       IdentifiedStructTypes.addNonOpaque(Ty);
   }
   // Self-map metadatas in the destination module. This is needed when
   // DebugTypeODRUniquing is enabled on the LLVMContext, since metadata in the
   // destination module may be reached from the source module.

llvm/lib/Transforms/IPO/StripSymbols.cpp

static void StripSymtab(ValueSymbolTable &ST, bool PreserveDbgInfo) {
   }
 }
 
 // Strip any named types of their names.
 static void StripTypeNames(Module &M, bool PreserveDbgInfo) {
   TypeFinder StructTypes;
   StructTypes.run(M, false);
 
-  for (StructType *STy : StructTypes) {
+  for (StructType *STy : StructTypes.structs()) {
     if (STy->isLiteral() || STy->getName().empty()) continue;
 
     if (PreserveDbgInfo && STy->getName().startswith("llvm.dbg"))
       continue;
 
     STy->setName("");
   }
 }

llvm/lib/Transforms/Utils/MetaRenamer.cpp

if (Name.startswith("llvm.") || (!Name.empty() && Name[0] == 1) ||
       continue;
 
     GV.setName("global");
   }
 
   // Rename all struct types
   TypeFinder StructTypes;
   StructTypes.run(M, true);
-  for (StructType *STy : StructTypes) {
+  for (StructType *STy : StructTypes.structs()) {
     StringRef Name = STy->getName();
     if (STy->isLiteral() || Name.empty() ||
         IsNameExcluded(Name, ExcludedStructsPrefixes))
       continue;
 
     SmallString<128> NameStorage;
     STy->setName(
         (Twine("struct.") + renamer.newName()).toStringRef(NameStorage));