Fix Linker instruction rewrites for modules with identical types

[klickverbot]

Summary

This fixes a severe bug in llvm::Linker that occurs when a type is actually represented by the same Type object in the two modules (as in, the pointers are equal).

Previously, only the top-level type was added to the MappedTypes in that case. If the contained types did not appear in another artifact on their own, this led the instruction rewrites, etc. that are run later to erroneously assume that they need to make changes.

I'm not quite sure what the easiest way to add a regression test for this would be, i.e. how to best get the LLVM command line tools to use the same Type instance.

lib/Linker/LinkModules.cpp

   Type *remapType(Type *SrcTy) override { return get(SrcTy); }
 
   bool areTypesIsomorphic(Type *DstTy, Type *SrcTy);
+
+  void addTrivialMapRecursively(Type *Ty);
 };
 }
 

   // Two identical types are clearly isomorphic.  Remember this
   // non-speculatively.
   if (DstTy == SrcTy) {
-    Entry = DstTy;
+    addTrivialMapRecursively(DstTy);
     return true;
   }
 

   return true;
 }
 
+/// For types which turn out to be the same Type instance in both modules,
+/// remembers this fact for it and all the contained types.
+///
+/// We need to be aware of this when performing the instruction rewrites
+/// laster on.
+void TypeMapTy::addTrivialMapRecursively(Type *Ty) {
+  Type *&Entry = MappedTypes[Ty];
+  if (Entry)
+    return;
+
+  Entry = Ty;
+  for (unsigned I = 0, E = Ty->getNumContainedTypes(); I != E; ++I) {
+    addTrivialMapRecursively(Ty->getContainedType(I));
+  }
+}
+
 void TypeMapTy::linkDefinedTypeBodies() {
   SmallVector<Type*, 16> Elements;
   for (StructType *SrcSTy : SrcDefinitionsToResolve) {