[IRMover] Do not drop names of struct types that are used

[jdoerfert]

Summary

When we link bitcode via clang (-mlink-bitcode-file) we can end up
removing the name of a struct type that is present in the user code
and the linked in file. This occurred for OpenMP codes but turned out
to be really hard to reproduce. The necessary code change to avoid
dropping those names is simple though and hopefully uncontroversial.

[lebedev.ri]

[jdoerfert]

In D122328#3403773, @lebedev.ri wrote:

As mentioned in the commit message, I didn't manage to create one. Spend hours on it now. Any constructive input welcome.

[jdoerfert]

Try a different strategy to avoid dropping used struct names

llvm/include/llvm/Linker/IRMover.h

 //===- IRMover.h ------------------------------------------------*- 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_LINKER_IRMOVER_H
 #define LLVM_LINKER_IRMOVER_H
 
 #include "llvm/ADT/ArrayRef.h"
 #include "llvm/ADT/DenseSet.h"
 #include "llvm/ADT/FunctionExtras.h"
+#include "llvm/ADT/iterator_range.h"
 #include <functional>
 
 namespace llvm {
 class Error;
 class GlobalValue;
 class Metadata;
 class Module;
 class StructType;
class IdentifiedStructTypeSet {
     DenseSet<StructType *, StructTypeKeyInfo> NonOpaqueStructTypes;
 
   public:
     void addNonOpaque(StructType *Ty);
     void switchToNonOpaque(StructType *Ty);
     void addOpaque(StructType *Ty);
     StructType *findNonOpaque(ArrayRef<Type *> ETypes, bool IsPacked);
     bool hasType(StructType *Ty);
+
+    using const_non_opaque_iterator =
+        decltype(NonOpaqueStructTypes)::const_iterator;
+    const_non_opaque_iterator begin_non_opaque() const {
+      return NonOpaqueStructTypes.begin();
+    }
+    const_non_opaque_iterator end_non_opaque() const {
+      return NonOpaqueStructTypes.end();
+    }
+    llvm::iterator_range<const_non_opaque_iterator> range_non_opaque() {
+      return llvm::make_range(begin_non_opaque(), end_non_opaque());
+    }
+
+    using const_opaque_iterator = decltype(OpaqueStructTypes)::const_iterator;
+    const_opaque_iterator begin_opaque() const {
+      return OpaqueStructTypes.begin();
+    }
+    const_opaque_iterator end_opaque() const { return OpaqueStructTypes.end(); }
+    llvm::iterator_range<const_opaque_iterator> range_opaque() {
+      return llvm::make_range(begin_opaque(), end_opaque());
+    }
   };
 
   IRMover(Module &M);
 
   typedef std::function<void(GlobalValue &)> ValueAdder;
   using LazyCallback =
       llvm::unique_function<void(GlobalValue &GV, ValueAdder Add)>;
 

llvm/lib/Linker/IRMover.cpp

 //===- lib/Linker/IRMover.cpp ---------------------------------------------===//
 //
 // 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/Linker/IRMover.h"
 #include "LinkDiagnosticInfo.h"
 #include "llvm/ADT/SetVector.h"
 #include "llvm/ADT/SmallPtrSet.h"
 #include "llvm/ADT/SmallString.h"
 #include "llvm/ADT/Triple.h"
 #include "llvm/IR/Constants.h"
 #include "llvm/IR/DebugInfoMetadata.h"
+#include "llvm/IR/DerivedTypes.h"
 #include "llvm/IR/DiagnosticPrinter.h"
 #include "llvm/IR/Function.h"
 #include "llvm/IR/GVMaterializer.h"
 #include "llvm/IR/GlobalValue.h"
 #include "llvm/IR/Intrinsics.h"
 #include "llvm/IR/Module.h"
 #include "llvm/IR/PseudoProbe.h"
 #include "llvm/IR/TypeFinder.h"
class TypeMapTy : public ValueMapTypeRemapper {
   SmallVector<StructType *, 16> SrcDefinitionsToResolve;
 
   /// This is the set of opaque types in the destination modules who are
   /// getting a body from the source module.
   SmallPtrSet<StructType *, 16> DstResolvedOpaqueTypes;
 
 public:
   TypeMapTy(IRMover::IdentifiedStructTypeSet &DstStructTypesSet)
-      : DstStructTypesSet(DstStructTypesSet) {}
+      : DstStructTypesSet(DstStructTypesSet) {
+    // Existing destination types are mapped to themselves as they are already
+    // available.
+    for (StructType *OpaqueSTy : DstStructTypesSet.range_opaque())
+      MappedTypes[OpaqueSTy] = OpaqueSTy;
+    for (StructType *NonOpaqueSTy : DstStructTypesSet.range_non_opaque())
+      MappedTypes[NonOpaqueSTy] = NonOpaqueSTy;
+  }
 
   IRMover::IdentifiedStructTypeSet &DstStructTypesSet;
   /// Indicate that the specified type in the destination module is conceptually
   /// equivalent to the specified type in the source module.
   void addTypeMapping(Type *DstTy, Type *SrcTy);
 
   /// Produce a body for an opaque type in the dest module from a type
   /// definition in the source module.