LLVM  3.7.0
LinkModules.cpp
Go to the documentation of this file.
1 //===- lib/Linker/LinkModules.cpp - Module Linker Implementation ----------===//
2 //
3 // The LLVM Compiler Infrastructure
4 //
5 // This file is distributed under the University of Illinois Open Source
6 // License. See LICENSE.TXT for details.
7 //
8 //===----------------------------------------------------------------------===//
9 //
10 // This file implements the LLVM module linker.
11 //
12 //===----------------------------------------------------------------------===//
13 
14 #include "llvm/Linker/Linker.h"
15 #include "llvm-c/Linker.h"
16 #include "llvm/ADT/Hashing.h"
17 #include "llvm/ADT/Optional.h"
18 #include "llvm/ADT/SetVector.h"
19 #include "llvm/ADT/SmallString.h"
20 #include "llvm/ADT/Statistic.h"
21 #include "llvm/ADT/Triple.h"
22 #include "llvm/IR/Constants.h"
23 #include "llvm/IR/DebugInfo.h"
24 #include "llvm/IR/DiagnosticInfo.h"
26 #include "llvm/IR/LLVMContext.h"
27 #include "llvm/IR/Module.h"
28 #include "llvm/IR/TypeFinder.h"
30 #include "llvm/Support/Debug.h"
33 #include <cctype>
34 #include <tuple>
35 using namespace llvm;
36 
37 
38 //===----------------------------------------------------------------------===//
39 // TypeMap implementation.
40 //===----------------------------------------------------------------------===//
41 
42 namespace {
43 class TypeMapTy : public ValueMapTypeRemapper {
44  /// This is a mapping from a source type to a destination type to use.
45  DenseMap<Type*, Type*> MappedTypes;
46 
47  /// When checking to see if two subgraphs are isomorphic, we speculatively
48  /// add types to MappedTypes, but keep track of them here in case we need to
49  /// roll back.
50  SmallVector<Type*, 16> SpeculativeTypes;
51 
52  SmallVector<StructType*, 16> SpeculativeDstOpaqueTypes;
53 
54  /// This is a list of non-opaque structs in the source module that are mapped
55  /// to an opaque struct in the destination module.
56  SmallVector<StructType*, 16> SrcDefinitionsToResolve;
57 
58  /// This is the set of opaque types in the destination modules who are
59  /// getting a body from the source module.
60  SmallPtrSet<StructType*, 16> DstResolvedOpaqueTypes;
61 
62 public:
63  TypeMapTy(Linker::IdentifiedStructTypeSet &DstStructTypesSet)
64  : DstStructTypesSet(DstStructTypesSet) {}
65 
66  Linker::IdentifiedStructTypeSet &DstStructTypesSet;
67  /// Indicate that the specified type in the destination module is conceptually
68  /// equivalent to the specified type in the source module.
69  void addTypeMapping(Type *DstTy, Type *SrcTy);
70 
71  /// Produce a body for an opaque type in the dest module from a type
72  /// definition in the source module.
73  void linkDefinedTypeBodies();
74 
75  /// Return the mapped type to use for the specified input type from the
76  /// source module.
77  Type *get(Type *SrcTy);
78  Type *get(Type *SrcTy, SmallPtrSet<StructType *, 8> &Visited);
79 
80  void finishType(StructType *DTy, StructType *STy, ArrayRef<Type *> ETypes);
81 
82  FunctionType *get(FunctionType *T) {
83  return cast<FunctionType>(get((Type *)T));
84  }
85 
86  /// Dump out the type map for debugging purposes.
87  void dump() const {
88  for (auto &Pair : MappedTypes) {
89  dbgs() << "TypeMap: ";
90  Pair.first->print(dbgs());
91  dbgs() << " => ";
92  Pair.second->print(dbgs());
93  dbgs() << '\n';
94  }
95  }
96 
97 private:
98  Type *remapType(Type *SrcTy) override { return get(SrcTy); }
99 
100  bool areTypesIsomorphic(Type *DstTy, Type *SrcTy);
101 };
102 }
103 
104 void TypeMapTy::addTypeMapping(Type *DstTy, Type *SrcTy) {
105  assert(SpeculativeTypes.empty());
106  assert(SpeculativeDstOpaqueTypes.empty());
107 
108  // Check to see if these types are recursively isomorphic and establish a
109  // mapping between them if so.
110  if (!areTypesIsomorphic(DstTy, SrcTy)) {
111  // Oops, they aren't isomorphic. Just discard this request by rolling out
112  // any speculative mappings we've established.
113  for (Type *Ty : SpeculativeTypes)
114  MappedTypes.erase(Ty);
115 
116  SrcDefinitionsToResolve.resize(SrcDefinitionsToResolve.size() -
117  SpeculativeDstOpaqueTypes.size());
118  for (StructType *Ty : SpeculativeDstOpaqueTypes)
119  DstResolvedOpaqueTypes.erase(Ty);
120  } else {
121  for (Type *Ty : SpeculativeTypes)
122  if (auto *STy = dyn_cast<StructType>(Ty))
123  if (STy->hasName())
124  STy->setName("");
125  }
126  SpeculativeTypes.clear();
127  SpeculativeDstOpaqueTypes.clear();
128 }
129 
130 /// Recursively walk this pair of types, returning true if they are isomorphic,
131 /// false if they are not.
132 bool TypeMapTy::areTypesIsomorphic(Type *DstTy, Type *SrcTy) {
133  // Two types with differing kinds are clearly not isomorphic.
134  if (DstTy->getTypeID() != SrcTy->getTypeID())
135  return false;
136 
137  // If we have an entry in the MappedTypes table, then we have our answer.
138  Type *&Entry = MappedTypes[SrcTy];
139  if (Entry)
140  return Entry == DstTy;
141 
142  // Two identical types are clearly isomorphic. Remember this
143  // non-speculatively.
144  if (DstTy == SrcTy) {
145  Entry = DstTy;
146  return true;
147  }
148 
149  // Okay, we have two types with identical kinds that we haven't seen before.
150 
151  // If this is an opaque struct type, special case it.
152  if (StructType *SSTy = dyn_cast<StructType>(SrcTy)) {
153  // Mapping an opaque type to any struct, just keep the dest struct.
154  if (SSTy->isOpaque()) {
155  Entry = DstTy;
156  SpeculativeTypes.push_back(SrcTy);
157  return true;
158  }
159 
160  // Mapping a non-opaque source type to an opaque dest. If this is the first
161  // type that we're mapping onto this destination type then we succeed. Keep
162  // the dest, but fill it in later. If this is the second (different) type
163  // that we're trying to map onto the same opaque type then we fail.
164  if (cast<StructType>(DstTy)->isOpaque()) {
165  // We can only map one source type onto the opaque destination type.
166  if (!DstResolvedOpaqueTypes.insert(cast<StructType>(DstTy)).second)
167  return false;
168  SrcDefinitionsToResolve.push_back(SSTy);
169  SpeculativeTypes.push_back(SrcTy);
170  SpeculativeDstOpaqueTypes.push_back(cast<StructType>(DstTy));
171  Entry = DstTy;
172  return true;
173  }
174  }
175 
176  // If the number of subtypes disagree between the two types, then we fail.
177  if (SrcTy->getNumContainedTypes() != DstTy->getNumContainedTypes())
178  return false;
179 
180  // Fail if any of the extra properties (e.g. array size) of the type disagree.
181  if (isa<IntegerType>(DstTy))
182  return false; // bitwidth disagrees.
183  if (PointerType *PT = dyn_cast<PointerType>(DstTy)) {
184  if (PT->getAddressSpace() != cast<PointerType>(SrcTy)->getAddressSpace())
185  return false;
186 
187  } else if (FunctionType *FT = dyn_cast<FunctionType>(DstTy)) {
188  if (FT->isVarArg() != cast<FunctionType>(SrcTy)->isVarArg())
189  return false;
190  } else if (StructType *DSTy = dyn_cast<StructType>(DstTy)) {
191  StructType *SSTy = cast<StructType>(SrcTy);
192  if (DSTy->isLiteral() != SSTy->isLiteral() ||
193  DSTy->isPacked() != SSTy->isPacked())
194  return false;
195  } else if (ArrayType *DATy = dyn_cast<ArrayType>(DstTy)) {
196  if (DATy->getNumElements() != cast<ArrayType>(SrcTy)->getNumElements())
197  return false;
198  } else if (VectorType *DVTy = dyn_cast<VectorType>(DstTy)) {
199  if (DVTy->getNumElements() != cast<VectorType>(SrcTy)->getNumElements())
200  return false;
201  }
202 
203  // Otherwise, we speculate that these two types will line up and recursively
204  // check the subelements.
205  Entry = DstTy;
206  SpeculativeTypes.push_back(SrcTy);
207 
208  for (unsigned I = 0, E = SrcTy->getNumContainedTypes(); I != E; ++I)
209  if (!areTypesIsomorphic(DstTy->getContainedType(I),
210  SrcTy->getContainedType(I)))
211  return false;
212 
213  // If everything seems to have lined up, then everything is great.
214  return true;
215 }
216 
217 void TypeMapTy::linkDefinedTypeBodies() {
218  SmallVector<Type*, 16> Elements;
219  for (StructType *SrcSTy : SrcDefinitionsToResolve) {
220  StructType *DstSTy = cast<StructType>(MappedTypes[SrcSTy]);
221  assert(DstSTy->isOpaque());
222 
223  // Map the body of the source type over to a new body for the dest type.
224  Elements.resize(SrcSTy->getNumElements());
225  for (unsigned I = 0, E = Elements.size(); I != E; ++I)
226  Elements[I] = get(SrcSTy->getElementType(I));
227 
228  DstSTy->setBody(Elements, SrcSTy->isPacked());
229  DstStructTypesSet.switchToNonOpaque(DstSTy);
230  }
231  SrcDefinitionsToResolve.clear();
232  DstResolvedOpaqueTypes.clear();
233 }
234 
235 void TypeMapTy::finishType(StructType *DTy, StructType *STy,
236  ArrayRef<Type *> ETypes) {
237  DTy->setBody(ETypes, STy->isPacked());
238 
239  // Steal STy's name.
240  if (STy->hasName()) {
241  SmallString<16> TmpName = STy->getName();
242  STy->setName("");
243  DTy->setName(TmpName);
244  }
245 
246  DstStructTypesSet.addNonOpaque(DTy);
247 }
248 
249 Type *TypeMapTy::get(Type *Ty) {
251  return get(Ty, Visited);
252 }
253 
254 Type *TypeMapTy::get(Type *Ty, SmallPtrSet<StructType *, 8> &Visited) {
255  // If we already have an entry for this type, return it.
256  Type **Entry = &MappedTypes[Ty];
257  if (*Entry)
258  return *Entry;
259 
260  // These are types that LLVM itself will unique.
261  bool IsUniqued = !isa<StructType>(Ty) || cast<StructType>(Ty)->isLiteral();
262 
263 #ifndef NDEBUG
264  if (!IsUniqued) {
265  for (auto &Pair : MappedTypes) {
266  assert(!(Pair.first != Ty && Pair.second == Ty) &&
267  "mapping to a source type");
268  }
269  }
270 #endif
271 
272  if (!IsUniqued && !Visited.insert(cast<StructType>(Ty)).second) {
274  return *Entry = DTy;
275  }
276 
277  // If this is not a recursive type, then just map all of the elements and
278  // then rebuild the type from inside out.
279  SmallVector<Type *, 4> ElementTypes;
280 
281  // If there are no element types to map, then the type is itself. This is
282  // true for the anonymous {} struct, things like 'float', integers, etc.
283  if (Ty->getNumContainedTypes() == 0 && IsUniqued)
284  return *Entry = Ty;
285 
286  // Remap all of the elements, keeping track of whether any of them change.
287  bool AnyChange = false;
288  ElementTypes.resize(Ty->getNumContainedTypes());
289  for (unsigned I = 0, E = Ty->getNumContainedTypes(); I != E; ++I) {
290  ElementTypes[I] = get(Ty->getContainedType(I), Visited);
291  AnyChange |= ElementTypes[I] != Ty->getContainedType(I);
292  }
293 
294  // If we found our type while recursively processing stuff, just use it.
295  Entry = &MappedTypes[Ty];
296  if (*Entry) {
297  if (auto *DTy = dyn_cast<StructType>(*Entry)) {
298  if (DTy->isOpaque()) {
299  auto *STy = cast<StructType>(Ty);
300  finishType(DTy, STy, ElementTypes);
301  }
302  }
303  return *Entry;
304  }
305 
306  // If all of the element types mapped directly over and the type is not
307  // a nomed struct, then the type is usable as-is.
308  if (!AnyChange && IsUniqued)
309  return *Entry = Ty;
310 
311  // Otherwise, rebuild a modified type.
312  switch (Ty->getTypeID()) {
313  default:
314  llvm_unreachable("unknown derived type to remap");
315  case Type::ArrayTyID:
316  return *Entry = ArrayType::get(ElementTypes[0],
317  cast<ArrayType>(Ty)->getNumElements());
318  case Type::VectorTyID:
319  return *Entry = VectorType::get(ElementTypes[0],
320  cast<VectorType>(Ty)->getNumElements());
321  case Type::PointerTyID:
322  return *Entry = PointerType::get(ElementTypes[0],
323  cast<PointerType>(Ty)->getAddressSpace());
324  case Type::FunctionTyID:
325  return *Entry = FunctionType::get(ElementTypes[0],
326  makeArrayRef(ElementTypes).slice(1),
327  cast<FunctionType>(Ty)->isVarArg());
328  case Type::StructTyID: {
329  auto *STy = cast<StructType>(Ty);
330  bool IsPacked = STy->isPacked();
331  if (IsUniqued)
332  return *Entry = StructType::get(Ty->getContext(), ElementTypes, IsPacked);
333 
334  // If the type is opaque, we can just use it directly.
335  if (STy->isOpaque()) {
336  DstStructTypesSet.addOpaque(STy);
337  return *Entry = Ty;
338  }
339 
340  if (StructType *OldT =
341  DstStructTypesSet.findNonOpaque(ElementTypes, IsPacked)) {
342  STy->setName("");
343  return *Entry = OldT;
344  }
345 
346  if (!AnyChange) {
347  DstStructTypesSet.addNonOpaque(STy);
348  return *Entry = Ty;
349  }
350 
352  finishType(DTy, STy, ElementTypes);
353  return *Entry = DTy;
354  }
355  }
356 }
357 
358 //===----------------------------------------------------------------------===//
359 // ModuleLinker implementation.
360 //===----------------------------------------------------------------------===//
361 
362 namespace {
363 class ModuleLinker;
364 
365 /// Creates prototypes for functions that are lazily linked on the fly. This
366 /// speeds up linking for modules with many/ lazily linked functions of which
367 /// few get used.
368 class ValueMaterializerTy : public ValueMaterializer {
369  TypeMapTy &TypeMap;
370  Module *DstM;
371  std::vector<GlobalValue *> &LazilyLinkGlobalValues;
372 
373 public:
374  ValueMaterializerTy(TypeMapTy &TypeMap, Module *DstM,
375  std::vector<GlobalValue *> &LazilyLinkGlobalValues)
376  : ValueMaterializer(), TypeMap(TypeMap), DstM(DstM),
377  LazilyLinkGlobalValues(LazilyLinkGlobalValues) {}
378 
379  Value *materializeValueFor(Value *V) override;
380 };
381 
382 class LinkDiagnosticInfo : public DiagnosticInfo {
383  const Twine &Msg;
384 
385 public:
386  LinkDiagnosticInfo(DiagnosticSeverity Severity, const Twine &Msg);
387  void print(DiagnosticPrinter &DP) const override;
388 };
389 LinkDiagnosticInfo::LinkDiagnosticInfo(DiagnosticSeverity Severity,
390  const Twine &Msg)
391  : DiagnosticInfo(DK_Linker, Severity), Msg(Msg) {}
392 void LinkDiagnosticInfo::print(DiagnosticPrinter &DP) const { DP << Msg; }
393 
394 /// This is an implementation class for the LinkModules function, which is the
395 /// entrypoint for this file.
396 class ModuleLinker {
397  Module *DstM, *SrcM;
398 
399  TypeMapTy TypeMap;
400  ValueMaterializerTy ValMaterializer;
401 
402  /// Mapping of values from what they used to be in Src, to what they are now
403  /// in DstM. ValueToValueMapTy is a ValueMap, which involves some overhead
404  /// due to the use of Value handles which the Linker doesn't actually need,
405  /// but this allows us to reuse the ValueMapper code.
407 
408  struct AppendingVarInfo {
409  GlobalVariable *NewGV; // New aggregate global in dest module.
410  const Constant *DstInit; // Old initializer from dest module.
411  const Constant *SrcInit; // Old initializer from src module.
412  };
413 
414  std::vector<AppendingVarInfo> AppendingVars;
415 
416  // Set of items not to link in from source.
417  SmallPtrSet<const Value *, 16> DoNotLinkFromSource;
418 
419  // Vector of GlobalValues to lazily link in.
420  std::vector<GlobalValue *> LazilyLinkGlobalValues;
421 
422  /// Functions that have replaced other functions.
423  SmallPtrSet<const Function *, 16> OverridingFunctions;
424 
425  DiagnosticHandlerFunction DiagnosticHandler;
426 
427  /// For symbol clashes, prefer those from Src.
428  bool OverrideFromSrc;
429 
430 public:
431  ModuleLinker(Module *dstM, Linker::IdentifiedStructTypeSet &Set, Module *srcM,
432  DiagnosticHandlerFunction DiagnosticHandler,
433  bool OverrideFromSrc)
434  : DstM(dstM), SrcM(srcM), TypeMap(Set),
435  ValMaterializer(TypeMap, DstM, LazilyLinkGlobalValues),
436  DiagnosticHandler(DiagnosticHandler), OverrideFromSrc(OverrideFromSrc) {
437  }
438 
439  bool run();
440 
441 private:
442  bool shouldLinkFromSource(bool &LinkFromSrc, const GlobalValue &Dest,
443  const GlobalValue &Src);
444 
445  /// Helper method for setting a message and returning an error code.
446  bool emitError(const Twine &Message) {
447  DiagnosticHandler(LinkDiagnosticInfo(DS_Error, Message));
448  return true;
449  }
450 
451  void emitWarning(const Twine &Message) {
452  DiagnosticHandler(LinkDiagnosticInfo(DS_Warning, Message));
453  }
454 
455  bool getComdatLeader(Module *M, StringRef ComdatName,
456  const GlobalVariable *&GVar);
457  bool computeResultingSelectionKind(StringRef ComdatName,
460  Comdat::SelectionKind &Result,
461  bool &LinkFromSrc);
462  std::map<const Comdat *, std::pair<Comdat::SelectionKind, bool>>
463  ComdatsChosen;
464  bool getComdatResult(const Comdat *SrcC, Comdat::SelectionKind &SK,
465  bool &LinkFromSrc);
466 
467  /// Given a global in the source module, return the global in the
468  /// destination module that is being linked to, if any.
469  GlobalValue *getLinkedToGlobal(const GlobalValue *SrcGV) {
470  // If the source has no name it can't link. If it has local linkage,
471  // there is no name match-up going on.
472  if (!SrcGV->hasName() || SrcGV->hasLocalLinkage())
473  return nullptr;
474 
475  // Otherwise see if we have a match in the destination module's symtab.
476  GlobalValue *DGV = DstM->getNamedValue(SrcGV->getName());
477  if (!DGV)
478  return nullptr;
479 
480  // If we found a global with the same name in the dest module, but it has
481  // internal linkage, we are really not doing any linkage here.
482  if (DGV->hasLocalLinkage())
483  return nullptr;
484 
485  // Otherwise, we do in fact link to the destination global.
486  return DGV;
487  }
488 
489  void computeTypeMapping();
490 
491  void upgradeMismatchedGlobalArray(StringRef Name);
492  void upgradeMismatchedGlobals();
493 
494  bool linkAppendingVarProto(GlobalVariable *DstGV,
495  const GlobalVariable *SrcGV);
496 
497  bool linkGlobalValueProto(GlobalValue *GV);
498  bool linkModuleFlagsMetadata();
499 
500  void linkAppendingVarInit(const AppendingVarInfo &AVI);
501 
502  void linkGlobalInit(GlobalVariable &Dst, GlobalVariable &Src);
503  bool linkFunctionBody(Function &Dst, Function &Src);
504  void linkAliasBody(GlobalAlias &Dst, GlobalAlias &Src);
505  bool linkGlobalValueBody(GlobalValue &Src);
506 
507  void linkNamedMDNodes();
508  void stripReplacedSubprograms();
509 };
510 }
511 
512 /// The LLVM SymbolTable class autorenames globals that conflict in the symbol
513 /// table. This is good for all clients except for us. Go through the trouble
514 /// to force this back.
516  // If the global doesn't force its name or if it already has the right name,
517  // there is nothing for us to do.
518  if (GV->hasLocalLinkage() || GV->getName() == Name)
519  return;
520 
521  Module *M = GV->getParent();
522 
523  // If there is a conflict, rename the conflict.
524  if (GlobalValue *ConflictGV = M->getNamedValue(Name)) {
525  GV->takeName(ConflictGV);
526  ConflictGV->setName(Name); // This will cause ConflictGV to get renamed
527  assert(ConflictGV->getName() != Name && "forceRenaming didn't work");
528  } else {
529  GV->setName(Name); // Force the name back
530  }
531 }
532 
533 /// copy additional attributes (those not needed to construct a GlobalValue)
534 /// from the SrcGV to the DestGV.
535 static void copyGVAttributes(GlobalValue *DestGV, const GlobalValue *SrcGV) {
536  DestGV->copyAttributesFrom(SrcGV);
537  forceRenaming(DestGV, SrcGV->getName());
538 }
539 
542  if (a == GlobalValue::HiddenVisibility)
543  return false;
544  if (b == GlobalValue::HiddenVisibility)
545  return true;
546  if (a == GlobalValue::ProtectedVisibility)
547  return false;
548  if (b == GlobalValue::ProtectedVisibility)
549  return true;
550  return false;
551 }
552 
553 /// Loop through the global variables in the src module and merge them into the
554 /// dest module.
555 static GlobalVariable *copyGlobalVariableProto(TypeMapTy &TypeMap, Module &DstM,
556  const GlobalVariable *SGVar) {
557  // No linking to be performed or linking from the source: simply create an
558  // identical version of the symbol over in the dest module... the
559  // initializer will be filled in later by LinkGlobalInits.
560  GlobalVariable *NewDGV = new GlobalVariable(
561  DstM, TypeMap.get(SGVar->getType()->getElementType()),
562  SGVar->isConstant(), SGVar->getLinkage(), /*init*/ nullptr,
563  SGVar->getName(), /*insertbefore*/ nullptr, SGVar->getThreadLocalMode(),
564  SGVar->getType()->getAddressSpace());
565 
566  return NewDGV;
567 }
568 
569 /// Link the function in the source module into the destination module if
570 /// needed, setting up mapping information.
571 static Function *copyFunctionProto(TypeMapTy &TypeMap, Module &DstM,
572  const Function *SF) {
573  // If there is no linkage to be performed or we are linking from the source,
574  // bring SF over.
575  return Function::Create(TypeMap.get(SF->getFunctionType()), SF->getLinkage(),
576  SF->getName(), &DstM);
577 }
578 
579 /// Set up prototypes for any aliases that come over from the source module.
580 static GlobalAlias *copyGlobalAliasProto(TypeMapTy &TypeMap, Module &DstM,
581  const GlobalAlias *SGA) {
582  // If there is no linkage to be performed or we're linking from the source,
583  // bring over SGA.
584  auto *PTy = cast<PointerType>(TypeMap.get(SGA->getType()));
585  return GlobalAlias::create(PTy, SGA->getLinkage(), SGA->getName(), &DstM);
586 }
587 
588 static GlobalValue *copyGlobalValueProto(TypeMapTy &TypeMap, Module &DstM,
589  const GlobalValue *SGV) {
590  GlobalValue *NewGV;
591  if (auto *SGVar = dyn_cast<GlobalVariable>(SGV))
592  NewGV = copyGlobalVariableProto(TypeMap, DstM, SGVar);
593  else if (auto *SF = dyn_cast<Function>(SGV))
594  NewGV = copyFunctionProto(TypeMap, DstM, SF);
595  else
596  NewGV = copyGlobalAliasProto(TypeMap, DstM, cast<GlobalAlias>(SGV));
597  copyGVAttributes(NewGV, SGV);
598  return NewGV;
599 }
600 
601 Value *ValueMaterializerTy::materializeValueFor(Value *V) {
602  auto *SGV = dyn_cast<GlobalValue>(V);
603  if (!SGV)
604  return nullptr;
605 
606  GlobalValue *DGV = copyGlobalValueProto(TypeMap, *DstM, SGV);
607 
608  if (Comdat *SC = SGV->getComdat()) {
609  if (auto *DGO = dyn_cast<GlobalObject>(DGV)) {
610  Comdat *DC = DstM->getOrInsertComdat(SC->getName());
611  DGO->setComdat(DC);
612  }
613  }
614 
615  LazilyLinkGlobalValues.push_back(SGV);
616  return DGV;
617 }
618 
619 bool ModuleLinker::getComdatLeader(Module *M, StringRef ComdatName,
620  const GlobalVariable *&GVar) {
621  const GlobalValue *GVal = M->getNamedValue(ComdatName);
622  if (const auto *GA = dyn_cast_or_null<GlobalAlias>(GVal)) {
623  GVal = GA->getBaseObject();
624  if (!GVal)
625  // We cannot resolve the size of the aliasee yet.
626  return emitError("Linking COMDATs named '" + ComdatName +
627  "': COMDAT key involves incomputable alias size.");
628  }
629 
630  GVar = dyn_cast_or_null<GlobalVariable>(GVal);
631  if (!GVar)
632  return emitError(
633  "Linking COMDATs named '" + ComdatName +
634  "': GlobalVariable required for data dependent selection!");
635 
636  return false;
637 }
638 
639 bool ModuleLinker::computeResultingSelectionKind(StringRef ComdatName,
642  Comdat::SelectionKind &Result,
643  bool &LinkFromSrc) {
644  // The ability to mix Comdat::SelectionKind::Any with
645  // Comdat::SelectionKind::Largest is a behavior that comes from COFF.
646  bool DstAnyOrLargest = Dst == Comdat::SelectionKind::Any ||
647  Dst == Comdat::SelectionKind::Largest;
648  bool SrcAnyOrLargest = Src == Comdat::SelectionKind::Any ||
649  Src == Comdat::SelectionKind::Largest;
650  if (DstAnyOrLargest && SrcAnyOrLargest) {
651  if (Dst == Comdat::SelectionKind::Largest ||
652  Src == Comdat::SelectionKind::Largest)
653  Result = Comdat::SelectionKind::Largest;
654  else
656  } else if (Src == Dst) {
657  Result = Dst;
658  } else {
659  return emitError("Linking COMDATs named '" + ComdatName +
660  "': invalid selection kinds!");
661  }
662 
663  switch (Result) {
665  // Go with Dst.
666  LinkFromSrc = false;
667  break;
668  case Comdat::SelectionKind::NoDuplicates:
669  return emitError("Linking COMDATs named '" + ComdatName +
670  "': noduplicates has been violated!");
671  case Comdat::SelectionKind::ExactMatch:
672  case Comdat::SelectionKind::Largest:
673  case Comdat::SelectionKind::SameSize: {
674  const GlobalVariable *DstGV;
675  const GlobalVariable *SrcGV;
676  if (getComdatLeader(DstM, ComdatName, DstGV) ||
677  getComdatLeader(SrcM, ComdatName, SrcGV))
678  return true;
679 
680  const DataLayout &DstDL = DstM->getDataLayout();
681  const DataLayout &SrcDL = SrcM->getDataLayout();
682  uint64_t DstSize =
684  uint64_t SrcSize =
686  if (Result == Comdat::SelectionKind::ExactMatch) {
687  if (SrcGV->getInitializer() != DstGV->getInitializer())
688  return emitError("Linking COMDATs named '" + ComdatName +
689  "': ExactMatch violated!");
690  LinkFromSrc = false;
691  } else if (Result == Comdat::SelectionKind::Largest) {
692  LinkFromSrc = SrcSize > DstSize;
693  } else if (Result == Comdat::SelectionKind::SameSize) {
694  if (SrcSize != DstSize)
695  return emitError("Linking COMDATs named '" + ComdatName +
696  "': SameSize violated!");
697  LinkFromSrc = false;
698  } else {
699  llvm_unreachable("unknown selection kind");
700  }
701  break;
702  }
703  }
704 
705  return false;
706 }
707 
708 bool ModuleLinker::getComdatResult(const Comdat *SrcC,
709  Comdat::SelectionKind &Result,
710  bool &LinkFromSrc) {
712  StringRef ComdatName = SrcC->getName();
713  Module::ComdatSymTabType &ComdatSymTab = DstM->getComdatSymbolTable();
714  Module::ComdatSymTabType::iterator DstCI = ComdatSymTab.find(ComdatName);
715 
716  if (DstCI == ComdatSymTab.end()) {
717  // Use the comdat if it is only available in one of the modules.
718  LinkFromSrc = true;
719  Result = SSK;
720  return false;
721  }
722 
723  const Comdat *DstC = &DstCI->second;
725  return computeResultingSelectionKind(ComdatName, SSK, DSK, Result,
726  LinkFromSrc);
727 }
728 
729 bool ModuleLinker::shouldLinkFromSource(bool &LinkFromSrc,
730  const GlobalValue &Dest,
731  const GlobalValue &Src) {
732  // Should we unconditionally use the Src?
733  if (OverrideFromSrc) {
734  LinkFromSrc = true;
735  return false;
736  }
737 
738  // We always have to add Src if it has appending linkage.
739  if (Src.hasAppendingLinkage()) {
740  LinkFromSrc = true;
741  return false;
742  }
743 
744  bool SrcIsDeclaration = Src.isDeclarationForLinker();
745  bool DestIsDeclaration = Dest.isDeclarationForLinker();
746 
747  if (SrcIsDeclaration) {
748  // If Src is external or if both Src & Dest are external.. Just link the
749  // external globals, we aren't adding anything.
750  if (Src.hasDLLImportStorageClass()) {
751  // If one of GVs is marked as DLLImport, result should be dllimport'ed.
752  LinkFromSrc = DestIsDeclaration;
753  return false;
754  }
755  // If the Dest is weak, use the source linkage.
756  LinkFromSrc = Dest.hasExternalWeakLinkage();
757  return false;
758  }
759 
760  if (DestIsDeclaration) {
761  // If Dest is external but Src is not:
762  LinkFromSrc = true;
763  return false;
764  }
765 
766  if (Src.hasCommonLinkage()) {
767  if (Dest.hasLinkOnceLinkage() || Dest.hasWeakLinkage()) {
768  LinkFromSrc = true;
769  return false;
770  }
771 
772  if (!Dest.hasCommonLinkage()) {
773  LinkFromSrc = false;
774  return false;
775  }
776 
777  const DataLayout &DL = Dest.getParent()->getDataLayout();
778  uint64_t DestSize = DL.getTypeAllocSize(Dest.getType()->getElementType());
779  uint64_t SrcSize = DL.getTypeAllocSize(Src.getType()->getElementType());
780  LinkFromSrc = SrcSize > DestSize;
781  return false;
782  }
783 
784  if (Src.isWeakForLinker()) {
785  assert(!Dest.hasExternalWeakLinkage());
786  assert(!Dest.hasAvailableExternallyLinkage());
787 
788  if (Dest.hasLinkOnceLinkage() && Src.hasWeakLinkage()) {
789  LinkFromSrc = true;
790  return false;
791  }
792 
793  LinkFromSrc = false;
794  return false;
795  }
796 
797  if (Dest.isWeakForLinker()) {
798  assert(Src.hasExternalLinkage());
799  LinkFromSrc = true;
800  return false;
801  }
802 
803  assert(!Src.hasExternalWeakLinkage());
804  assert(!Dest.hasExternalWeakLinkage());
805  assert(Dest.hasExternalLinkage() && Src.hasExternalLinkage() &&
806  "Unexpected linkage type!");
807  return emitError("Linking globals named '" + Src.getName() +
808  "': symbol multiply defined!");
809 }
810 
811 /// Loop over all of the linked values to compute type mappings. For example,
812 /// if we link "extern Foo *x" and "Foo *x = NULL", then we have two struct
813 /// types 'Foo' but one got renamed when the module was loaded into the same
814 /// LLVMContext.
815 void ModuleLinker::computeTypeMapping() {
816  for (GlobalValue &SGV : SrcM->globals()) {
817  GlobalValue *DGV = getLinkedToGlobal(&SGV);
818  if (!DGV)
819  continue;
820 
821  if (!DGV->hasAppendingLinkage() || !SGV.hasAppendingLinkage()) {
822  TypeMap.addTypeMapping(DGV->getType(), SGV.getType());
823  continue;
824  }
825 
826  // Unify the element type of appending arrays.
827  ArrayType *DAT = cast<ArrayType>(DGV->getType()->getElementType());
828  ArrayType *SAT = cast<ArrayType>(SGV.getType()->getElementType());
829  TypeMap.addTypeMapping(DAT->getElementType(), SAT->getElementType());
830  }
831 
832  for (GlobalValue &SGV : *SrcM) {
833  if (GlobalValue *DGV = getLinkedToGlobal(&SGV))
834  TypeMap.addTypeMapping(DGV->getType(), SGV.getType());
835  }
836 
837  for (GlobalValue &SGV : SrcM->aliases()) {
838  if (GlobalValue *DGV = getLinkedToGlobal(&SGV))
839  TypeMap.addTypeMapping(DGV->getType(), SGV.getType());
840  }
841 
842  // Incorporate types by name, scanning all the types in the source module.
843  // At this point, the destination module may have a type "%foo = { i32 }" for
844  // example. When the source module got loaded into the same LLVMContext, if
845  // it had the same type, it would have been renamed to "%foo.42 = { i32 }".
846  std::vector<StructType *> Types = SrcM->getIdentifiedStructTypes();
847  for (StructType *ST : Types) {
848  if (!ST->hasName())
849  continue;
850 
851  // Check to see if there is a dot in the name followed by a digit.
852  size_t DotPos = ST->getName().rfind('.');
853  if (DotPos == 0 || DotPos == StringRef::npos ||
854  ST->getName().back() == '.' ||
855  !isdigit(static_cast<unsigned char>(ST->getName()[DotPos + 1])))
856  continue;
857 
858  // Check to see if the destination module has a struct with the prefix name.
859  StructType *DST = DstM->getTypeByName(ST->getName().substr(0, DotPos));
860  if (!DST)
861  continue;
862 
863  // Don't use it if this actually came from the source module. They're in
864  // the same LLVMContext after all. Also don't use it unless the type is
865  // actually used in the destination module. This can happen in situations
866  // like this:
867  //
868  // Module A Module B
869  // -------- --------
870  // %Z = type { %A } %B = type { %C.1 }
871  // %A = type { %B.1, [7 x i8] } %C.1 = type { i8* }
872  // %B.1 = type { %C } %A.2 = type { %B.3, [5 x i8] }
873  // %C = type { i8* } %B.3 = type { %C.1 }
874  //
875  // When we link Module B with Module A, the '%B' in Module B is
876  // used. However, that would then use '%C.1'. But when we process '%C.1',
877  // we prefer to take the '%C' version. So we are then left with both
878  // '%C.1' and '%C' being used for the same types. This leads to some
879  // variables using one type and some using the other.
880  if (TypeMap.DstStructTypesSet.hasType(DST))
881  TypeMap.addTypeMapping(DST, ST);
882  }
883 
884  // Now that we have discovered all of the type equivalences, get a body for
885  // any 'opaque' types in the dest module that are now resolved.
886  TypeMap.linkDefinedTypeBodies();
887 }
888 
890  ArrayType *ATy = cast<ArrayType>(GV->getType()->getElementType());
891  StructType *OldTy = cast<StructType>(ATy->getElementType());
892  assert(OldTy->getNumElements() == 2 && "Expected to upgrade from 2 elements");
893 
894  // Get the upgraded 3 element type.
895  PointerType *VoidPtrTy = Type::getInt8Ty(GV->getContext())->getPointerTo();
896  Type *Tys[3] = {OldTy->getElementType(0), OldTy->getElementType(1),
897  VoidPtrTy};
898  StructType *NewTy = StructType::get(GV->getContext(), Tys, false);
899 
900  // Build new constants with a null third field filled in.
901  Constant *OldInitC = GV->getInitializer();
902  ConstantArray *OldInit = dyn_cast<ConstantArray>(OldInitC);
903  if (!OldInit && !isa<ConstantAggregateZero>(OldInitC))
904  // Invalid initializer; give up.
905  return;
906  std::vector<Constant *> Initializers;
907  if (OldInit && OldInit->getNumOperands()) {
908  Value *Null = Constant::getNullValue(VoidPtrTy);
909  for (Use &U : OldInit->operands()) {
910  ConstantStruct *Init = cast<ConstantStruct>(U.get());
911  Initializers.push_back(ConstantStruct::get(
912  NewTy, Init->getOperand(0), Init->getOperand(1), Null, nullptr));
913  }
914  }
915  assert(Initializers.size() == ATy->getNumElements() &&
916  "Failed to copy all array elements");
917 
918  // Replace the old GV with a new one.
919  ATy = ArrayType::get(NewTy, Initializers.size());
920  Constant *NewInit = ConstantArray::get(ATy, Initializers);
921  GlobalVariable *NewGV = new GlobalVariable(
922  *GV->getParent(), ATy, GV->isConstant(), GV->getLinkage(), NewInit, "",
923  GV, GV->getThreadLocalMode(), GV->getType()->getAddressSpace(),
924  GV->isExternallyInitialized());
925  NewGV->copyAttributesFrom(GV);
926  NewGV->takeName(GV);
927  assert(GV->use_empty() && "program cannot use initializer list");
928  GV->eraseFromParent();
929 }
930 
931 void ModuleLinker::upgradeMismatchedGlobalArray(StringRef Name) {
932  // Look for the global arrays.
933  auto *DstGV = dyn_cast_or_null<GlobalVariable>(DstM->getNamedValue(Name));
934  if (!DstGV)
935  return;
936  auto *SrcGV = dyn_cast_or_null<GlobalVariable>(SrcM->getNamedValue(Name));
937  if (!SrcGV)
938  return;
939 
940  // Check if the types already match.
941  auto *DstTy = cast<ArrayType>(DstGV->getType()->getElementType());
942  auto *SrcTy =
943  cast<ArrayType>(TypeMap.get(SrcGV->getType()->getElementType()));
944  if (DstTy == SrcTy)
945  return;
946 
947  // Grab the element types. We can only upgrade an array of a two-field
948  // struct. Only bother if the other one has three-fields.
949  auto *DstEltTy = cast<StructType>(DstTy->getElementType());
950  auto *SrcEltTy = cast<StructType>(SrcTy->getElementType());
951  if (DstEltTy->getNumElements() == 2 && SrcEltTy->getNumElements() == 3) {
952  upgradeGlobalArray(DstGV);
953  return;
954  }
955  if (DstEltTy->getNumElements() == 3 && SrcEltTy->getNumElements() == 2)
956  upgradeGlobalArray(SrcGV);
957 
958  // We can't upgrade any other differences.
959 }
960 
961 void ModuleLinker::upgradeMismatchedGlobals() {
962  upgradeMismatchedGlobalArray("llvm.global_ctors");
963  upgradeMismatchedGlobalArray("llvm.global_dtors");
964 }
965 
966 /// If there were any appending global variables, link them together now.
967 /// Return true on error.
968 bool ModuleLinker::linkAppendingVarProto(GlobalVariable *DstGV,
969  const GlobalVariable *SrcGV) {
970 
971  if (!SrcGV->hasAppendingLinkage() || !DstGV->hasAppendingLinkage())
972  return emitError("Linking globals named '" + SrcGV->getName() +
973  "': can only link appending global with another appending global!");
974 
975  ArrayType *DstTy = cast<ArrayType>(DstGV->getType()->getElementType());
976  ArrayType *SrcTy =
977  cast<ArrayType>(TypeMap.get(SrcGV->getType()->getElementType()));
978  Type *EltTy = DstTy->getElementType();
979 
980  // Check to see that they two arrays agree on type.
981  if (EltTy != SrcTy->getElementType())
982  return emitError("Appending variables with different element types!");
983  if (DstGV->isConstant() != SrcGV->isConstant())
984  return emitError("Appending variables linked with different const'ness!");
985 
986  if (DstGV->getAlignment() != SrcGV->getAlignment())
987  return emitError(
988  "Appending variables with different alignment need to be linked!");
989 
990  if (DstGV->getVisibility() != SrcGV->getVisibility())
991  return emitError(
992  "Appending variables with different visibility need to be linked!");
993 
994  if (DstGV->hasUnnamedAddr() != SrcGV->hasUnnamedAddr())
995  return emitError(
996  "Appending variables with different unnamed_addr need to be linked!");
997 
998  if (StringRef(DstGV->getSection()) != SrcGV->getSection())
999  return emitError(
1000  "Appending variables with different section name need to be linked!");
1001 
1002  uint64_t NewSize = DstTy->getNumElements() + SrcTy->getNumElements();
1003  ArrayType *NewType = ArrayType::get(EltTy, NewSize);
1004 
1005  // Create the new global variable.
1006  GlobalVariable *NG =
1007  new GlobalVariable(*DstGV->getParent(), NewType, SrcGV->isConstant(),
1008  DstGV->getLinkage(), /*init*/nullptr, /*name*/"", DstGV,
1009  DstGV->getThreadLocalMode(),
1010  DstGV->getType()->getAddressSpace());
1011 
1012  // Propagate alignment, visibility and section info.
1013  copyGVAttributes(NG, DstGV);
1014 
1015  AppendingVarInfo AVI;
1016  AVI.NewGV = NG;
1017  AVI.DstInit = DstGV->getInitializer();
1018  AVI.SrcInit = SrcGV->getInitializer();
1019  AppendingVars.push_back(AVI);
1020 
1021  // Replace any uses of the two global variables with uses of the new
1022  // global.
1023  ValueMap[SrcGV] = ConstantExpr::getBitCast(NG, TypeMap.get(SrcGV->getType()));
1024 
1025  DstGV->replaceAllUsesWith(ConstantExpr::getBitCast(NG, DstGV->getType()));
1026  DstGV->eraseFromParent();
1027 
1028  // Track the source variable so we don't try to link it.
1029  DoNotLinkFromSource.insert(SrcGV);
1030 
1031  return false;
1032 }
1033 
1034 bool ModuleLinker::linkGlobalValueProto(GlobalValue *SGV) {
1035  GlobalValue *DGV = getLinkedToGlobal(SGV);
1036 
1037  // Handle the ultra special appending linkage case first.
1038  if (DGV && DGV->hasAppendingLinkage())
1039  return linkAppendingVarProto(cast<GlobalVariable>(DGV),
1040  cast<GlobalVariable>(SGV));
1041 
1042  bool LinkFromSrc = true;
1043  Comdat *C = nullptr;
1045  bool HasUnnamedAddr = SGV->hasUnnamedAddr();
1046 
1047  if (const Comdat *SC = SGV->getComdat()) {
1049  std::tie(SK, LinkFromSrc) = ComdatsChosen[SC];
1050  C = DstM->getOrInsertComdat(SC->getName());
1051  C->setSelectionKind(SK);
1052  } else if (DGV) {
1053  if (shouldLinkFromSource(LinkFromSrc, *DGV, *SGV))
1054  return true;
1055  }
1056 
1057  if (!LinkFromSrc) {
1058  // Track the source global so that we don't attempt to copy it over when
1059  // processing global initializers.
1060  DoNotLinkFromSource.insert(SGV);
1061 
1062  if (DGV)
1063  // Make sure to remember this mapping.
1064  ValueMap[SGV] =
1065  ConstantExpr::getBitCast(DGV, TypeMap.get(SGV->getType()));
1066  }
1067 
1068  if (DGV) {
1069  Visibility = isLessConstraining(Visibility, DGV->getVisibility())
1070  ? DGV->getVisibility()
1071  : Visibility;
1072  HasUnnamedAddr = HasUnnamedAddr && DGV->hasUnnamedAddr();
1073  }
1074 
1075  if (!LinkFromSrc && !DGV)
1076  return false;
1077 
1078  GlobalValue *NewGV;
1079  if (!LinkFromSrc) {
1080  NewGV = DGV;
1081  } else {
1082  // If the GV is to be lazily linked, don't create it just yet.
1083  // The ValueMaterializerTy will deal with creating it if it's used.
1084  if (!DGV && !OverrideFromSrc &&
1085  (SGV->hasLocalLinkage() || SGV->hasLinkOnceLinkage() ||
1087  DoNotLinkFromSource.insert(SGV);
1088  return false;
1089  }
1090 
1091  NewGV = copyGlobalValueProto(TypeMap, *DstM, SGV);
1092 
1093  if (DGV && isa<Function>(DGV))
1094  if (auto *NewF = dyn_cast<Function>(NewGV))
1095  OverridingFunctions.insert(NewF);
1096  }
1097 
1098  NewGV->setUnnamedAddr(HasUnnamedAddr);
1099  NewGV->setVisibility(Visibility);
1100 
1101  if (auto *NewGO = dyn_cast<GlobalObject>(NewGV)) {
1102  if (C)
1103  NewGO->setComdat(C);
1104 
1105  if (DGV && DGV->hasCommonLinkage() && SGV->hasCommonLinkage())
1106  NewGO->setAlignment(std::max(DGV->getAlignment(), SGV->getAlignment()));
1107  }
1108 
1109  if (auto *NewGVar = dyn_cast<GlobalVariable>(NewGV)) {
1110  auto *DGVar = dyn_cast_or_null<GlobalVariable>(DGV);
1111  auto *SGVar = dyn_cast<GlobalVariable>(SGV);
1112  if (DGVar && SGVar && DGVar->isDeclaration() && SGVar->isDeclaration() &&
1113  (!DGVar->isConstant() || !SGVar->isConstant()))
1114  NewGVar->setConstant(false);
1115  }
1116 
1117  // Make sure to remember this mapping.
1118  if (NewGV != DGV) {
1119  if (DGV) {
1120  DGV->replaceAllUsesWith(ConstantExpr::getBitCast(NewGV, DGV->getType()));
1121  DGV->eraseFromParent();
1122  }
1123  ValueMap[SGV] = NewGV;
1124  }
1125 
1126  return false;
1127 }
1128 
1129 static void getArrayElements(const Constant *C,
1131  unsigned NumElements = cast<ArrayType>(C->getType())->getNumElements();
1132 
1133  for (unsigned i = 0; i != NumElements; ++i)
1134  Dest.push_back(C->getAggregateElement(i));
1135 }
1136 
1137 void ModuleLinker::linkAppendingVarInit(const AppendingVarInfo &AVI) {
1138  // Merge the initializer.
1139  SmallVector<Constant *, 16> DstElements;
1140  getArrayElements(AVI.DstInit, DstElements);
1141 
1142  SmallVector<Constant *, 16> SrcElements;
1143  getArrayElements(AVI.SrcInit, SrcElements);
1144 
1145  ArrayType *NewType = cast<ArrayType>(AVI.NewGV->getType()->getElementType());
1146 
1147  StringRef Name = AVI.NewGV->getName();
1148  bool IsNewStructor =
1149  (Name == "llvm.global_ctors" || Name == "llvm.global_dtors") &&
1150  cast<StructType>(NewType->getElementType())->getNumElements() == 3;
1151 
1152  for (auto *V : SrcElements) {
1153  if (IsNewStructor) {
1154  Constant *Key = V->getAggregateElement(2);
1155  if (DoNotLinkFromSource.count(Key))
1156  continue;
1157  }
1158  DstElements.push_back(
1159  MapValue(V, ValueMap, RF_None, &TypeMap, &ValMaterializer));
1160  }
1161  if (IsNewStructor) {
1162  NewType = ArrayType::get(NewType->getElementType(), DstElements.size());
1163  AVI.NewGV->mutateType(PointerType::get(NewType, 0));
1164  }
1165 
1166  AVI.NewGV->setInitializer(ConstantArray::get(NewType, DstElements));
1167 }
1168 
1169 /// Update the initializers in the Dest module now that all globals that may be
1170 /// referenced are in Dest.
1171 void ModuleLinker::linkGlobalInit(GlobalVariable &Dst, GlobalVariable &Src) {
1172  // Figure out what the initializer looks like in the dest module.
1173  Dst.setInitializer(MapValue(Src.getInitializer(), ValueMap, RF_None, &TypeMap,
1174  &ValMaterializer));
1175 }
1176 
1177 /// Copy the source function over into the dest function and fix up references
1178 /// to values. At this point we know that Dest is an external function, and
1179 /// that Src is not.
1180 bool ModuleLinker::linkFunctionBody(Function &Dst, Function &Src) {
1181  assert(Dst.isDeclaration() && !Src.isDeclaration());
1182 
1183  // Materialize if needed.
1184  if (std::error_code EC = Src.materialize())
1185  return emitError(EC.message());
1186 
1187  // Link in the prefix data.
1188  if (Src.hasPrefixData())
1189  Dst.setPrefixData(MapValue(Src.getPrefixData(), ValueMap, RF_None, &TypeMap,
1190  &ValMaterializer));
1191 
1192  // Link in the prologue data.
1193  if (Src.hasPrologueData())
1195  &TypeMap, &ValMaterializer));
1196 
1197  // Link in the personality function.
1198  if (Src.hasPersonalityFn())
1200  &TypeMap, &ValMaterializer));
1201 
1202  // Go through and convert function arguments over, remembering the mapping.
1204  for (Argument &Arg : Src.args()) {
1205  DI->setName(Arg.getName()); // Copy the name over.
1206 
1207  // Add a mapping to our mapping.
1208  ValueMap[&Arg] = DI;
1209  ++DI;
1210  }
1211 
1212  // Copy over the metadata attachments.
1214  Src.getAllMetadata(MDs);
1215  for (const auto &I : MDs)
1216  Dst.setMetadata(I.first, MapMetadata(I.second, ValueMap, RF_None, &TypeMap,
1217  &ValMaterializer));
1218 
1219  // Splice the body of the source function into the dest function.
1220  Dst.getBasicBlockList().splice(Dst.end(), Src.getBasicBlockList());
1221 
1222  // At this point, all of the instructions and values of the function are now
1223  // copied over. The only problem is that they are still referencing values in
1224  // the Source function as operands. Loop through all of the operands of the
1225  // functions and patch them up to point to the local versions.
1226  for (BasicBlock &BB : Dst)
1227  for (Instruction &I : BB)
1229  &ValMaterializer);
1230 
1231  // There is no need to map the arguments anymore.
1232  for (Argument &Arg : Src.args())
1233  ValueMap.erase(&Arg);
1234 
1235  Src.dematerialize();
1236  return false;
1237 }
1238 
1239 void ModuleLinker::linkAliasBody(GlobalAlias &Dst, GlobalAlias &Src) {
1240  Constant *Aliasee = Src.getAliasee();
1241  Constant *Val =
1242  MapValue(Aliasee, ValueMap, RF_None, &TypeMap, &ValMaterializer);
1243  Dst.setAliasee(Val);
1244 }
1245 
1246 bool ModuleLinker::linkGlobalValueBody(GlobalValue &Src) {
1247  Value *Dst = ValueMap[&Src];
1248  assert(Dst);
1249  if (auto *F = dyn_cast<Function>(&Src))
1250  return linkFunctionBody(cast<Function>(*Dst), *F);
1251  if (auto *GVar = dyn_cast<GlobalVariable>(&Src)) {
1252  linkGlobalInit(cast<GlobalVariable>(*Dst), *GVar);
1253  return false;
1254  }
1255  linkAliasBody(cast<GlobalAlias>(*Dst), cast<GlobalAlias>(Src));
1256  return false;
1257 }
1258 
1259 /// Insert all of the named MDNodes in Src into the Dest module.
1260 void ModuleLinker::linkNamedMDNodes() {
1261  const NamedMDNode *SrcModFlags = SrcM->getModuleFlagsMetadata();
1262  for (const NamedMDNode &NMD : SrcM->named_metadata()) {
1263  // Don't link module flags here. Do them separately.
1264  if (&NMD == SrcModFlags)
1265  continue;
1266  NamedMDNode *DestNMD = DstM->getOrInsertNamedMetadata(NMD.getName());
1267  // Add Src elements into Dest node.
1268  for (const MDNode *op : NMD.operands())
1269  DestNMD->addOperand(
1270  MapMetadata(op, ValueMap, RF_None, &TypeMap, &ValMaterializer));
1271  }
1272 }
1273 
1274 /// Drop DISubprograms that have been superseded.
1275 ///
1276 /// FIXME: this creates an asymmetric result: we strip functions from losing
1277 /// subprograms in DstM, but leave losing subprograms in SrcM.
1278 /// TODO: Remove this logic once the backend can correctly determine canonical
1279 /// subprograms.
1280 void ModuleLinker::stripReplacedSubprograms() {
1281  // Avoid quadratic runtime by returning early when there's nothing to do.
1282  if (OverridingFunctions.empty())
1283  return;
1284 
1285  // Move the functions now, so the set gets cleared even on early returns.
1286  auto Functions = std::move(OverridingFunctions);
1287  OverridingFunctions.clear();
1288 
1289  // Drop functions from subprograms if they've been overridden by the new
1290  // compile unit.
1291  NamedMDNode *CompileUnits = DstM->getNamedMetadata("llvm.dbg.cu");
1292  if (!CompileUnits)
1293  return;
1294  for (unsigned I = 0, E = CompileUnits->getNumOperands(); I != E; ++I) {
1295  auto *CU = cast<DICompileUnit>(CompileUnits->getOperand(I));
1296  assert(CU && "Expected valid compile unit");
1297 
1298  for (DISubprogram *SP : CU->getSubprograms()) {
1299  if (!SP || !SP->getFunction() || !Functions.count(SP->getFunction()))
1300  continue;
1301 
1302  // Prevent DebugInfoFinder from tagging this as the canonical subprogram,
1303  // since the canonical one is in the incoming module.
1304  SP->replaceFunction(nullptr);
1305  }
1306  }
1307 }
1308 
1309 /// Merge the linker flags in Src into the Dest module.
1310 bool ModuleLinker::linkModuleFlagsMetadata() {
1311  // If the source module has no module flags, we are done.
1312  const NamedMDNode *SrcModFlags = SrcM->getModuleFlagsMetadata();
1313  if (!SrcModFlags) return false;
1314 
1315  // If the destination module doesn't have module flags yet, then just copy
1316  // over the source module's flags.
1317  NamedMDNode *DstModFlags = DstM->getOrInsertModuleFlagsMetadata();
1318  if (DstModFlags->getNumOperands() == 0) {
1319  for (unsigned I = 0, E = SrcModFlags->getNumOperands(); I != E; ++I)
1320  DstModFlags->addOperand(SrcModFlags->getOperand(I));
1321 
1322  return false;
1323  }
1324 
1325  // First build a map of the existing module flags and requirements.
1327  SmallSetVector<MDNode*, 16> Requirements;
1328  for (unsigned I = 0, E = DstModFlags->getNumOperands(); I != E; ++I) {
1329  MDNode *Op = DstModFlags->getOperand(I);
1330  ConstantInt *Behavior = mdconst::extract<ConstantInt>(Op->getOperand(0));
1331  MDString *ID = cast<MDString>(Op->getOperand(1));
1332 
1333  if (Behavior->getZExtValue() == Module::Require) {
1334  Requirements.insert(cast<MDNode>(Op->getOperand(2)));
1335  } else {
1336  Flags[ID] = std::make_pair(Op, I);
1337  }
1338  }
1339 
1340  // Merge in the flags from the source module, and also collect its set of
1341  // requirements.
1342  bool HasErr = false;
1343  for (unsigned I = 0, E = SrcModFlags->getNumOperands(); I != E; ++I) {
1344  MDNode *SrcOp = SrcModFlags->getOperand(I);
1345  ConstantInt *SrcBehavior =
1346  mdconst::extract<ConstantInt>(SrcOp->getOperand(0));
1347  MDString *ID = cast<MDString>(SrcOp->getOperand(1));
1348  MDNode *DstOp;
1349  unsigned DstIndex;
1350  std::tie(DstOp, DstIndex) = Flags.lookup(ID);
1351  unsigned SrcBehaviorValue = SrcBehavior->getZExtValue();
1352 
1353  // If this is a requirement, add it and continue.
1354  if (SrcBehaviorValue == Module::Require) {
1355  // If the destination module does not already have this requirement, add
1356  // it.
1357  if (Requirements.insert(cast<MDNode>(SrcOp->getOperand(2)))) {
1358  DstModFlags->addOperand(SrcOp);
1359  }
1360  continue;
1361  }
1362 
1363  // If there is no existing flag with this ID, just add it.
1364  if (!DstOp) {
1365  Flags[ID] = std::make_pair(SrcOp, DstModFlags->getNumOperands());
1366  DstModFlags->addOperand(SrcOp);
1367  continue;
1368  }
1369 
1370  // Otherwise, perform a merge.
1371  ConstantInt *DstBehavior =
1372  mdconst::extract<ConstantInt>(DstOp->getOperand(0));
1373  unsigned DstBehaviorValue = DstBehavior->getZExtValue();
1374 
1375  // If either flag has override behavior, handle it first.
1376  if (DstBehaviorValue == Module::Override) {
1377  // Diagnose inconsistent flags which both have override behavior.
1378  if (SrcBehaviorValue == Module::Override &&
1379  SrcOp->getOperand(2) != DstOp->getOperand(2)) {
1380  HasErr |= emitError("linking module flags '" + ID->getString() +
1381  "': IDs have conflicting override values");
1382  }
1383  continue;
1384  } else if (SrcBehaviorValue == Module::Override) {
1385  // Update the destination flag to that of the source.
1386  DstModFlags->setOperand(DstIndex, SrcOp);
1387  Flags[ID].first = SrcOp;
1388  continue;
1389  }
1390 
1391  // Diagnose inconsistent merge behavior types.
1392  if (SrcBehaviorValue != DstBehaviorValue) {
1393  HasErr |= emitError("linking module flags '" + ID->getString() +
1394  "': IDs have conflicting behaviors");
1395  continue;
1396  }
1397 
1398  auto replaceDstValue = [&](MDNode *New) {
1399  Metadata *FlagOps[] = {DstOp->getOperand(0), ID, New};
1400  MDNode *Flag = MDNode::get(DstM->getContext(), FlagOps);
1401  DstModFlags->setOperand(DstIndex, Flag);
1402  Flags[ID].first = Flag;
1403  };
1404 
1405  // Perform the merge for standard behavior types.
1406  switch (SrcBehaviorValue) {
1407  case Module::Require:
1408  case Module::Override: llvm_unreachable("not possible");
1409  case Module::Error: {
1410  // Emit an error if the values differ.
1411  if (SrcOp->getOperand(2) != DstOp->getOperand(2)) {
1412  HasErr |= emitError("linking module flags '" + ID->getString() +
1413  "': IDs have conflicting values");
1414  }
1415  continue;
1416  }
1417  case Module::Warning: {
1418  // Emit a warning if the values differ.
1419  if (SrcOp->getOperand(2) != DstOp->getOperand(2)) {
1420  emitWarning("linking module flags '" + ID->getString() +
1421  "': IDs have conflicting values");
1422  }
1423  continue;
1424  }
1425  case Module::Append: {
1426  MDNode *DstValue = cast<MDNode>(DstOp->getOperand(2));
1427  MDNode *SrcValue = cast<MDNode>(SrcOp->getOperand(2));
1429  MDs.reserve(DstValue->getNumOperands() + SrcValue->getNumOperands());
1430  MDs.append(DstValue->op_begin(), DstValue->op_end());
1431  MDs.append(SrcValue->op_begin(), SrcValue->op_end());
1432 
1433  replaceDstValue(MDNode::get(DstM->getContext(), MDs));
1434  break;
1435  }
1436  case Module::AppendUnique: {
1438  MDNode *DstValue = cast<MDNode>(DstOp->getOperand(2));
1439  MDNode *SrcValue = cast<MDNode>(SrcOp->getOperand(2));
1440  Elts.insert(DstValue->op_begin(), DstValue->op_end());
1441  Elts.insert(SrcValue->op_begin(), SrcValue->op_end());
1442 
1443  replaceDstValue(MDNode::get(DstM->getContext(),
1444  makeArrayRef(Elts.begin(), Elts.end())));
1445  break;
1446  }
1447  }
1448  }
1449 
1450  // Check all of the requirements.
1451  for (unsigned I = 0, E = Requirements.size(); I != E; ++I) {
1452  MDNode *Requirement = Requirements[I];
1453  MDString *Flag = cast<MDString>(Requirement->getOperand(0));
1454  Metadata *ReqValue = Requirement->getOperand(1);
1455 
1456  MDNode *Op = Flags[Flag].first;
1457  if (!Op || Op->getOperand(2) != ReqValue) {
1458  HasErr |= emitError("linking module flags '" + Flag->getString() +
1459  "': does not have the required value");
1460  continue;
1461  }
1462  }
1463 
1464  return HasErr;
1465 }
1466 
1467 // This function returns true if the triples match.
1468 static bool triplesMatch(const Triple &T0, const Triple &T1) {
1469  // If vendor is apple, ignore the version number.
1470  if (T0.getVendor() == Triple::Apple)
1471  return T0.getArch() == T1.getArch() &&
1472  T0.getSubArch() == T1.getSubArch() &&
1473  T0.getVendor() == T1.getVendor() &&
1474  T0.getOS() == T1.getOS();
1475 
1476  return T0 == T1;
1477 }
1478 
1479 // This function returns the merged triple.
1480 static std::string mergeTriples(const Triple &SrcTriple, const Triple &DstTriple) {
1481  // If vendor is apple, pick the triple with the larger version number.
1482  if (SrcTriple.getVendor() == Triple::Apple)
1483  if (DstTriple.isOSVersionLT(SrcTriple))
1484  return SrcTriple.str();
1485 
1486  return DstTriple.str();
1487 }
1488 
1489 bool ModuleLinker::run() {
1490  assert(DstM && "Null destination module");
1491  assert(SrcM && "Null source module");
1492 
1493  // Inherit the target data from the source module if the destination module
1494  // doesn't have one already.
1495  if (DstM->getDataLayout().isDefault())
1496  DstM->setDataLayout(SrcM->getDataLayout());
1497 
1498  if (SrcM->getDataLayout() != DstM->getDataLayout()) {
1499  emitWarning("Linking two modules of different data layouts: '" +
1500  SrcM->getModuleIdentifier() + "' is '" +
1501  SrcM->getDataLayoutStr() + "' whereas '" +
1502  DstM->getModuleIdentifier() + "' is '" +
1503  DstM->getDataLayoutStr() + "'\n");
1504  }
1505 
1506  // Copy the target triple from the source to dest if the dest's is empty.
1507  if (DstM->getTargetTriple().empty() && !SrcM->getTargetTriple().empty())
1508  DstM->setTargetTriple(SrcM->getTargetTriple());
1509 
1510  Triple SrcTriple(SrcM->getTargetTriple()), DstTriple(DstM->getTargetTriple());
1511 
1512  if (!SrcM->getTargetTriple().empty() && !triplesMatch(SrcTriple, DstTriple))
1513  emitWarning("Linking two modules of different target triples: " +
1514  SrcM->getModuleIdentifier() + "' is '" +
1515  SrcM->getTargetTriple() + "' whereas '" +
1516  DstM->getModuleIdentifier() + "' is '" +
1517  DstM->getTargetTriple() + "'\n");
1518 
1519  DstM->setTargetTriple(mergeTriples(SrcTriple, DstTriple));
1520 
1521  // Append the module inline asm string.
1522  if (!SrcM->getModuleInlineAsm().empty()) {
1523  if (DstM->getModuleInlineAsm().empty())
1524  DstM->setModuleInlineAsm(SrcM->getModuleInlineAsm());
1525  else
1526  DstM->setModuleInlineAsm(DstM->getModuleInlineAsm()+"\n"+
1527  SrcM->getModuleInlineAsm());
1528  }
1529 
1530  // Loop over all of the linked values to compute type mappings.
1531  computeTypeMapping();
1532 
1533  ComdatsChosen.clear();
1534  for (const auto &SMEC : SrcM->getComdatSymbolTable()) {
1535  const Comdat &C = SMEC.getValue();
1536  if (ComdatsChosen.count(&C))
1537  continue;
1539  bool LinkFromSrc;
1540  if (getComdatResult(&C, SK, LinkFromSrc))
1541  return true;
1542  ComdatsChosen[&C] = std::make_pair(SK, LinkFromSrc);
1543  }
1544 
1545  // Upgrade mismatched global arrays.
1546  upgradeMismatchedGlobals();
1547 
1548  // Insert all of the globals in src into the DstM module... without linking
1549  // initializers (which could refer to functions not yet mapped over).
1550  for (GlobalVariable &GV : SrcM->globals())
1551  if (linkGlobalValueProto(&GV))
1552  return true;
1553 
1554  // Link the functions together between the two modules, without doing function
1555  // bodies... this just adds external function prototypes to the DstM
1556  // function... We do this so that when we begin processing function bodies,
1557  // all of the global values that may be referenced are available in our
1558  // ValueMap.
1559  for (Function &F :*SrcM)
1560  if (linkGlobalValueProto(&F))
1561  return true;
1562 
1563  // If there were any aliases, link them now.
1564  for (GlobalAlias &GA : SrcM->aliases())
1565  if (linkGlobalValueProto(&GA))
1566  return true;
1567 
1568  for (const AppendingVarInfo &AppendingVar : AppendingVars)
1569  linkAppendingVarInit(AppendingVar);
1570 
1571  for (const auto &Entry : DstM->getComdatSymbolTable()) {
1572  const Comdat &C = Entry.getValue();
1573  if (C.getSelectionKind() == Comdat::Any)
1574  continue;
1575  const GlobalValue *GV = SrcM->getNamedValue(C.getName());
1576  if (GV)
1577  MapValue(GV, ValueMap, RF_None, &TypeMap, &ValMaterializer);
1578  }
1579 
1580  // Strip replaced subprograms before mapping any metadata -- so that we're
1581  // not changing metadata from the source module (note that
1582  // linkGlobalValueBody() eventually calls RemapInstruction() and therefore
1583  // MapMetadata()) -- but after linking global value protocols -- so that
1584  // OverridingFunctions has been built.
1585  stripReplacedSubprograms();
1586 
1587  // Link in the function bodies that are defined in the source module into
1588  // DstM.
1589  for (Function &SF : *SrcM) {
1590  // Skip if no body (function is external).
1591  if (SF.isDeclaration())
1592  continue;
1593 
1594  // Skip if not linking from source.
1595  if (DoNotLinkFromSource.count(&SF))
1596  continue;
1597 
1598  if (linkGlobalValueBody(SF))
1599  return true;
1600  }
1601 
1602  // Resolve all uses of aliases with aliasees.
1603  for (GlobalAlias &Src : SrcM->aliases()) {
1604  if (DoNotLinkFromSource.count(&Src))
1605  continue;
1606  linkGlobalValueBody(Src);
1607  }
1608 
1609  // Remap all of the named MDNodes in Src into the DstM module. We do this
1610  // after linking GlobalValues so that MDNodes that reference GlobalValues
1611  // are properly remapped.
1612  linkNamedMDNodes();
1613 
1614  // Merge the module flags into the DstM module.
1615  if (linkModuleFlagsMetadata())
1616  return true;
1617 
1618  // Update the initializers in the DstM module now that all globals that may
1619  // be referenced are in DstM.
1620  for (GlobalVariable &Src : SrcM->globals()) {
1621  // Only process initialized GV's or ones not already in dest.
1622  if (!Src.hasInitializer() || DoNotLinkFromSource.count(&Src))
1623  continue;
1624  linkGlobalValueBody(Src);
1625  }
1626 
1627  // Process vector of lazily linked in functions.
1628  while (!LazilyLinkGlobalValues.empty()) {
1629  GlobalValue *SGV = LazilyLinkGlobalValues.back();
1630  LazilyLinkGlobalValues.pop_back();
1631 
1632  assert(!SGV->isDeclaration() && "users should not pass down decls");
1633  if (linkGlobalValueBody(*SGV))
1634  return true;
1635  }
1636 
1637  return false;
1638 }
1639 
1640 Linker::StructTypeKeyInfo::KeyTy::KeyTy(ArrayRef<Type *> E, bool P)
1641  : ETypes(E), IsPacked(P) {}
1642 
1644  : ETypes(ST->elements()), IsPacked(ST->isPacked()) {}
1645 
1647  if (IsPacked != That.IsPacked)
1648  return false;
1649  if (ETypes != That.ETypes)
1650  return false;
1651  return true;
1652 }
1653 
1655  return !this->operator==(That);
1656 }
1657 
1660 }
1661 
1664 }
1665 
1667  return hash_combine(hash_combine_range(Key.ETypes.begin(), Key.ETypes.end()),
1668  Key.IsPacked);
1669 }
1670 
1672  return getHashValue(KeyTy(ST));
1673 }
1674 
1676  const StructType *RHS) {
1677  if (RHS == getEmptyKey() || RHS == getTombstoneKey())
1678  return false;
1679  return LHS == KeyTy(RHS);
1680 }
1681 
1683  const StructType *RHS) {
1684  if (RHS == getEmptyKey())
1685  return LHS == getEmptyKey();
1686 
1687  if (RHS == getTombstoneKey())
1688  return LHS == getTombstoneKey();
1689 
1690  return KeyTy(LHS) == KeyTy(RHS);
1691 }
1692 
1694  assert(!Ty->isOpaque());
1695  NonOpaqueStructTypes.insert(Ty);
1696 }
1697 
1699  assert(!Ty->isOpaque());
1700  NonOpaqueStructTypes.insert(Ty);
1701  bool Removed = OpaqueStructTypes.erase(Ty);
1702  (void)Removed;
1703  assert(Removed);
1704 }
1705 
1707  assert(Ty->isOpaque());
1708  OpaqueStructTypes.insert(Ty);
1709 }
1710 
1711 StructType *
1713  bool IsPacked) {
1714  Linker::StructTypeKeyInfo::KeyTy Key(ETypes, IsPacked);
1715  auto I = NonOpaqueStructTypes.find_as(Key);
1716  if (I == NonOpaqueStructTypes.end())
1717  return nullptr;
1718  return *I;
1719 }
1720 
1722  if (Ty->isOpaque())
1723  return OpaqueStructTypes.count(Ty);
1724  auto I = NonOpaqueStructTypes.find(Ty);
1725  if (I == NonOpaqueStructTypes.end())
1726  return false;
1727  return *I == Ty;
1728 }
1729 
1730 void Linker::init(Module *M, DiagnosticHandlerFunction DiagnosticHandler) {
1731  this->Composite = M;
1732  this->DiagnosticHandler = DiagnosticHandler;
1733 
1734  TypeFinder StructTypes;
1735  StructTypes.run(*M, true);
1736  for (StructType *Ty : StructTypes) {
1737  if (Ty->isOpaque())
1738  IdentifiedStructTypes.addOpaque(Ty);
1739  else
1740  IdentifiedStructTypes.addNonOpaque(Ty);
1741  }
1742 }
1743 
1745  init(M, DiagnosticHandler);
1746 }
1747 
1749  init(M, [this](const DiagnosticInfo &DI) {
1750  Composite->getContext().diagnose(DI);
1751  });
1752 }
1753 
1755 }
1756 
1758  delete Composite;
1759  Composite = nullptr;
1760 }
1761 
1762 bool Linker::linkInModule(Module *Src, bool OverrideSymbols) {
1763  ModuleLinker TheLinker(Composite, IdentifiedStructTypes, Src,
1764  DiagnosticHandler, OverrideSymbols);
1765  bool RetCode = TheLinker.run();
1766  Composite->dropTriviallyDeadConstantArrays();
1767  return RetCode;
1768 }
1769 
1771  init(Dst, DiagnosticHandler);
1772 }
1773 
1774 //===----------------------------------------------------------------------===//
1775 // LinkModules entrypoint.
1776 //===----------------------------------------------------------------------===//
1777 
1778 /// This function links two modules together, with the resulting Dest module
1779 /// modified to be the composite of the two input modules. If an error occurs,
1780 /// true is returned and ErrorMsg (if not null) is set to indicate the problem.
1781 /// Upon failure, the Dest module could be in a modified state, and shouldn't be
1782 /// relied on to be consistent.
1784  DiagnosticHandlerFunction DiagnosticHandler) {
1785  Linker L(Dest, DiagnosticHandler);
1786  return L.linkInModule(Src);
1787 }
1788 
1789 bool Linker::LinkModules(Module *Dest, Module *Src) {
1790  Linker L(Dest);
1791  return L.linkInModule(Src);
1792 }
1793 
1794 //===----------------------------------------------------------------------===//
1795 // C API.
1796 //===----------------------------------------------------------------------===//
1797 
1799  LLVMLinkerMode Unused, char **OutMessages) {
1800  Module *D = unwrap(Dest);
1801  std::string Message;
1802  raw_string_ostream Stream(Message);
1803  DiagnosticPrinterRawOStream DP(Stream);
1804 
1805  LLVMBool Result = Linker::LinkModules(
1806  D, unwrap(Src), [&](const DiagnosticInfo &DI) { DI.print(DP); });
1807 
1808  if (OutMessages && Result) {
1809  Stream.flush();
1810  *OutMessages = strdup(Message.c_str());
1811  }
1812  return Result;
1813 }
void setVisibility(VisibilityTypes V)
Definition: GlobalValue.h:145
OSType getOS() const
getOS - Get the parsed operating system type of this triple.
Definition: Triple.h:251
bool operator!=(const KeyTy &that) const
void setPersonalityFn(Constant *C)
Definition: Function.cpp:1001
A parsed version of the target data layout string in and methods for querying it. ...
Definition: DataLayout.h:104
LinkageTypes getLinkage() const
Definition: GlobalValue.h:289
VisibilityTypes getVisibility() const
Definition: GlobalValue.h:139
virtual void copyAttributesFrom(const GlobalValue *Src)
Copy all additional attributes (those not needed to create a GlobalValue) from the GlobalValue Src to...
Definition: Globals.cpp:57
LLVM Argument representation.
Definition: Argument.h:35
Constant * getPrologueData() const
Definition: Function.cpp:956
static GlobalAlias * copyGlobalAliasProto(TypeMapTy &TypeMap, Module &DstM, const GlobalAlias *SGA)
Set up prototypes for any aliases that come over from the source module.
bool hasName() const
Definition: Value.h:228
ValueT lookup(const KeyT &Val) const
lookup - Return the entry for the specified key, or a default constructed value if no such entry exis...
Definition: DenseMap.h:159
bool isOpaque() const
isOpaque - Return true if this is a type with an identity that has no body specified yet...
Definition: DerivedTypes.h:250
bool operator==(const KeyTy &that) const
static bool LinkModules(Module *Dest, Module *Src, DiagnosticHandlerFunction DiagnosticHandler)
This function links two modules together, with the resulting Dest module modified to be the composite...
A Module instance is used to store all the information related to an LLVM module. ...
Definition: Module.h:114
void deleteModule()
iterator end()
Definition: Function.h:459
DiagnosticSeverity
Defines the different supported severity of a diagnostic.
unsigned getNumOperands() const
Definition: User.h:138
unsigned getNumOperands() const
Return number of MDNode operands.
Definition: Metadata.h:942
void addOperand(MDNode *M)
Definition: Metadata.cpp:971
bool hasAppendingLinkage() const
Definition: GlobalValue.h:277
static PointerType * get(Type *ElementType, unsigned AddressSpace)
PointerType::get - This constructs a pointer to an object of the specified type in a numbered address...
Definition: Type.cpp:738
iterator find(StringRef Key)
Definition: StringMap.h:265
bool hasAvailableExternallyLinkage() const
Definition: GlobalValue.h:261
static volatile int * Null
op_iterator op_begin() const
Definition: Metadata.h:928
12: Structures
Definition: Type.h:71
const std::string & str() const
Definition: Triple.h:306
bool hasPrologueData() const
Definition: Function.h:509
Metadata node.
Definition: Metadata.h:740
F(f)
unsigned getAddressSpace() const
Return the address space of the Pointer type.
Definition: DerivedTypes.h:472
static bool isLessConstraining(GlobalValue::VisibilityTypes a, GlobalValue::VisibilityTypes b)
ELFYAML::ELF_STV Visibility
Definition: ELFYAML.cpp:590
#define op(i)
14: Pointers
Definition: Type.h:73
void reserve(size_type N)
Definition: SmallVector.h:401
const Constant * getInitializer() const
getInitializer - Return the initializer for this global variable.
void setOperand(unsigned I, MDNode *New)
Definition: Metadata.cpp:973
11: Functions
Definition: Type.h:70
iterator end()
Get an iterator to the end of the SetVector.
Definition: SetVector.h:79
const Constant * getAliasee() const
Definition: GlobalAlias.h:81
static void getArrayElements(const Constant *C, SmallVectorImpl< Constant * > &Dest)
op_iterator op_end() const
Definition: Metadata.h:931
size_type size() const
Determine the number of elements in the SetVector.
Definition: SetVector.h:64
Type * getPointerElementType() const
Definition: Type.h:366
StringRef getName() const
Return a constant reference to the value's name.
Definition: Value.cpp:188
static bool triplesMatch(const Triple &T0, const Triple &T1)
bool isPacked() const
Definition: DerivedTypes.h:242
A tuple of MDNodes.
Definition: Metadata.h:1127
bool hasCommonLinkage() const
Definition: GlobalValue.h:282
static StructType * getEmptyKey()
Twine - A lightweight data structure for efficiently representing the concatenation of temporary valu...
Definition: Twine.h:79
ArrayRef< T > makeArrayRef(const T &OneElt)
Construct an ArrayRef from a single element.
Definition: ArrayRef.h:308
void setInitializer(Constant *InitVal)
setInitializer - Sets the initializer for this global variable, removing any existing initializer if ...
Definition: Globals.cpp:198
StructType - Class to represent struct types.
Definition: DerivedTypes.h:191
#define llvm_unreachable(msg)
Marks that the current location is not supposed to be reachable.
Definition: ErrorHandling.h:98
A Use represents the edge between a Value definition and its users.
Definition: Use.h:69
This class consists of common code factored out of the SmallVector class to reduce code duplication b...
Definition: APInt.h:33
bool isLiteral() const
isLiteral - Return true if this type is uniqued by structural equivalence, false if it is a struct de...
Definition: DerivedTypes.h:246
void setMetadata(unsigned KindID, MDNode *MD)
Set a particular kind of metadata attachment.
Definition: Metadata.cpp:1191
void setName(const Twine &Name)
Change the name of the value.
Definition: Value.cpp:250
Interface for custom diagnostic printing.
void eraseFromParent() override
eraseFromParent - This method unlinks 'this' from the containing module and deletes it...
Definition: Globals.cpp:194
static void copyGVAttributes(GlobalValue *DestGV, const GlobalValue *SrcGV)
copy additional attributes (those not needed to construct a GlobalValue) from the SrcGV to the DestGV...
StringRef getName() const
Definition: Comdat.cpp:25
Linker(Module *M, DiagnosticHandlerFunction DiagnosticHandler)
uint64_t getZExtValue() const
Return the constant as a 64-bit unsigned integer value after it has been zero extended as appropriate...
Definition: Constants.h:117
Subprogram description.
FunctionType - Class to represent function types.
Definition: DerivedTypes.h:96
bool insert(const value_type &X)
Insert a new element into the SetVector.
Definition: SetVector.h:102
LLVMContext & getContext() const
getContext - Return the LLVMContext in which this type was uniqued.
Definition: Type.h:125
#define T
unsigned getAlignment() const
Definition: GlobalObject.h:46
ArrayType - Class to represent array types.
Definition: DerivedTypes.h:336
VisibilityTypes
An enumeration for the kinds of visibility of global values.
Definition: GlobalValue.h:54
iterator begin()
Get an iterator to the beginning of the SetVector.
Definition: SetVector.h:69
static FunctionType * get(Type *Result, ArrayRef< Type * > Params, bool isVarArg)
FunctionType::get - This static method is the primary way of constructing a FunctionType.
Definition: Type.cpp:361
This class provides the core functionality of linking in LLVM.
Definition: Linker/Linker.h:27
ArrayRef - Represent a constant reference to an array (0 or more elements consecutively in memory)...
Definition: ArrayRef.h:31
SmallString - A SmallString is just a SmallVector with methods and accessors that make it work better...
Definition: SmallString.h:25
TypeID getTypeID() const
getTypeID - Return the type id for the type.
Definition: Type.h:134
static void forceRenaming(GlobalValue *GV, StringRef Name)
The LLVM SymbolTable class autorenames globals that conflict in the symbol table. ...
ArchType getArch() const
getArch - Get the parsed architecture type of this triple.
Definition: Triple.h:242
void replaceAllUsesWith(Value *V)
Change all uses of this to point to a new Value.
Definition: Value.cpp:351
void takeName(Value *V)
Transfer the name from V to this value.
Definition: Value.cpp:256
bool linkInModule(Module *Src, bool OverrideSymbols=false)
Link Src into the composite.
Type * getElementType() const
Definition: DerivedTypes.h:323
PointerType - Class to represent pointers.
Definition: DerivedTypes.h:449
RF_IgnoreMissingEntries - If this flag is set, the remapper ignores entries that are not in the value...
Definition: ValueMapper.h:62
SubArchType getSubArch() const
getSubArch - get the parsed subarchitecture type for this triple.
Definition: Triple.h:245
Flag
These should be considered private to the implementation of the MCInstrDesc class.
Definition: MCInstrDesc.h:97
static void upgradeGlobalArray(GlobalVariable *GV)
static bool isWeakForLinker(LinkageTypes Linkage)
Whether the definition of this global may be replaced at link time.
Definition: GlobalValue.h:254
LLVMBool LLVMLinkModules(LLVMModuleRef Dest, LLVMModuleRef Src, LLVMLinkerMode Unused, char **OutMessages)
static GlobalVariable * copyGlobalVariableProto(TypeMapTy &TypeMap, Module &DstM, const GlobalVariable *SGVar)
Loop through the global variables in the src module and merge them into the dest module.
#define P(N)
ValueMaterializer - This is a class that can be implemented by clients to materialize Values on deman...
Definition: ValueMapper.h:39
DataLayout * unwrap(LLVMTargetDataRef P)
Definition: DataLayout.h:465
This is the base abstract class for diagnostic reporting in the backend.
void dump(const SparseBitVector< ElementSize > &LHS, raw_ostream &out)
LLVM Basic Block Representation.
Definition: BasicBlock.h:65
The instances of the Type class are immutable: once they are created, they are never changed...
Definition: Type.h:45
Type * getContainedType(unsigned i) const
getContainedType - This method is used to implement the type iterator (defined at the end of the file...
Definition: Type.h:332
This is an important base class in LLVM.
Definition: Constant.h:41
Metadata * MapMetadata(const Metadata *MD, ValueToValueMapTy &VM, RemapFlags Flags=RF_None, ValueMapTypeRemapper *TypeMapper=nullptr, ValueMaterializer *Materializer=nullptr)
This file contains the declarations for the subclasses of Constant, which represent the different fla...
std::pair< iterator, bool > insert(PtrType Ptr)
Inserts Ptr if and only if there is no element in the container equal to Ptr.
Definition: SmallPtrSet.h:264
static void RemapInstruction(Instruction *I, ValueToValueMapTy &VMap)
RemapInstruction - Convert the instruction operands from referencing the current values into those sp...
Definition: LoopUnroll.cpp:49
LLVMLinkerMode
Definition: c/Linker.h:24
bool hasPersonalityFn() const
Get the personality function associated with this function.
Definition: Function.h:132
static Function * copyFunctionProto(TypeMapTy &TypeMap, Module &DstM, const Function *SF)
Link the function in the source module into the destination module if needed, setting up mapping info...
Value * MapValue(const Value *V, ValueToValueMapTy &VM, RemapFlags Flags=RF_None, ValueMapTypeRemapper *TypeMapper=nullptr, ValueMaterializer *Materializer=nullptr)
Definition: ValueMapper.cpp:28
KeyTy(ArrayRef< Type * > E, bool P)
uint64_t getNumElements() const
Definition: DerivedTypes.h:352
MDNode * getOperand(unsigned i) const
Definition: Metadata.cpp:965
Value * getOperand(unsigned i) const
Definition: User.h:118
op_range operands()
Definition: User.h:191
arg_iterator arg_begin()
Definition: Function.h:472
SelectionKind getSelectionKind() const
Definition: Comdat.h:42
Constant * getAggregateElement(unsigned Elt) const
getAggregateElement - For aggregates (struct/array/vector) return the constant that corresponds to th...
Definition: Constants.cpp:250
void setConstant(bool Val)
unsigned getNumContainedTypes() const
getNumContainedTypes - Return the number of types in the derived type.
Definition: Type.h:339
int LLVMBool
Definition: Support.h:29
bool hasWeakLinkage() const
Definition: GlobalValue.h:268
LLVMContext & getContext() const
All values hold a context through their type.
Definition: Value.cpp:519
virtual void print(DiagnosticPrinter &DP) const =0
Print using the given DP a user-friendly message.
void setBody(ArrayRef< Type * > Elements, bool isPacked=false)
setBody - Specify a body for an opaque identified type.
Definition: Type.cpp:424
void setModule(Module *Dst)
Set the composite to the passed-in module.
Triple - Helper class for working with autoconf configuration names.
Definition: Triple.h:44
static unsigned getHashValue(const KeyTy &Key)
const char * getSection() const
Definition: GlobalObject.h:57
13: Arrays
Definition: Type.h:72
bool hasExternalWeakLinkage() const
Definition: GlobalValue.h:281
StringRef getString() const
Definition: Metadata.cpp:375
bool hasExternalLinkage() const
Definition: GlobalValue.h:260
bool hasDLLImportStorageClass() const
Definition: GlobalValue.h:167
const MDOperand & getOperand(unsigned I) const
Definition: Metadata.h:936
A SetVector that performs no allocations if smaller than a certain size.
Definition: SetVector.h:217
const BasicBlockListType & getBasicBlockList() const
Definition: Function.h:436
SmallPtrSet - This class implements a set which is optimized for holding SmallSize or less elements...
Definition: SmallPtrSet.h:299
Comdat * getComdat()
Definition: Globals.cpp:116
This is the shared class of boolean and integer constants.
Definition: Constants.h:47
void setSelectionKind(SelectionKind Val)
Definition: Comdat.h:43
15: SIMD 'packed' format, or other vector type
Definition: Type.h:74
uint64_t getTypeAllocSize(Type *Ty) const
Returns the offset in bytes between successive objects of the specified type, including alignment pad...
Definition: DataLayout.h:388
void run(const Module &M, bool onlyNamed)
Definition: TypeFinder.cpp:23
static StructType * get(LLVMContext &Context, ArrayRef< Type * > Elements, bool isPacked=false)
StructType::get - This static method is the primary way to create a literal StructType.
Definition: Type.cpp:404
bool hasName() const
hasName - Return true if this is a named struct that has a non-empty name.
Definition: DerivedTypes.h:256
This is a 'vector' (really, a variable-sized array), optimized for the case when the array is small...
Definition: SmallVector.h:861
Module.h This file contains the declarations for the Module class.
Type * getType() const
All values are typed, get the type of this value.
Definition: Value.h:222
static std::string mergeTriples(const Triple &SrcTriple, const Triple &DstTriple)
void setUnnamedAddr(bool Val)
Definition: GlobalValue.h:131
void getAllMetadata(SmallVectorImpl< std::pair< unsigned, MDNode * >> &MDs) const
Get all current metadata attachments.
Definition: Metadata.cpp:1216
std::function< void(const DiagnosticInfo &)> DiagnosticHandlerFunction
CHAIN = SC CHAIN, Imm128 - System call.
static bool isEqual(const KeyTy &LHS, const StructType *RHS)
void splice(iterator where, iplist &L2)
Definition: ilist.h:570
raw_ostream & dbgs()
dbgs() - This returns a reference to a raw_ostream for debugging messages.
Definition: Debug.cpp:123
VectorType - Class to represent vector types.
Definition: DerivedTypes.h:362
ConstantArray - Constant Array Declarations.
Definition: Constants.h:356
hash_code hash_combine(const Ts &...args)
Combine values into a single hash_code.
Definition: Hashing.h:603
bool isConstant() const
If the value is a global constant, its value is immutable throughout the runtime execution of the pro...
StringRef getName() const
getName - Return the name for this struct type if it has an identity.
Definition: Type.cpp:583
LLVM_ATTRIBUTE_UNUSED_RESULT std::enable_if< !is_simple_type< Y >::value, typename cast_retty< X, const Y >::ret_type >::type dyn_cast(const Y &Val)
Definition: Casting.h:285
hash_code hash_combine_range(InputIteratorT first, InputIteratorT last)
Compute a hash_code for a sequence of values.
Definition: Hashing.h:481
ValueMapTypeRemapper - This is a class that can be implemented by clients to remap types when cloning...
Definition: ValueMapper.h:27
bool isOSVersionLT(unsigned Major, unsigned Minor=0, unsigned Micro=0) const
isOSVersionLT - Helper function for doing comparisons against version numbers included in the target ...
Definition: Triple.h:355
Basic diagnostic printer that uses an underlying raw_ostream.
StructType * findNonOpaque(ArrayRef< Type * > ETypes, bool IsPacked)
ThreadLocalMode getThreadLocalMode() const
Definition: GlobalValue.h:160
bool hasLinkOnceLinkage() const
Definition: GlobalValue.h:264
void setName(StringRef Name)
setName - Change the name of this type to the specified name, or to a name with a suffix if there is ...
Definition: Type.cpp:439
PointerType * getType() const
Global values are always pointers.
Definition: GlobalValue.h:185
const DataLayout & getDataLayout() const
Get the data layout for the module's target platform.
Definition: Module.cpp:372
Constant * getPersonalityFn() const
Definition: Function.h:133
bool isDeclaration() const
Return true if the primary definition of this global value is outside of the current translation unit...
Definition: Globals.cpp:128
#define I(x, y, z)
Definition: MD5.cpp:54
FunctionType * getFunctionType() const
Definition: Function.cpp:227
void setPrologueData(Constant *PrologueData)
Definition: Function.cpp:964
static ArrayType * get(Type *ElementType, uint64_t NumElements)
ArrayType::get - This static method is the primary way to construct an ArrayType. ...
Definition: Type.cpp:686
bool hasPrefixData() const
Definition: Function.h:502
void diagnose(const DiagnosticInfo &DI)
Report a message to the currently installed diagnostic handler.
Constant * getPrefixData() const
Definition: Function.cpp:927
bool hasLocalLinkage() const
Definition: GlobalValue.h:280
struct LLVMOpaqueModule * LLVMModuleRef
The top-level container for all other LLVM Intermediate Representation (IR) objects.
Definition: Core.h:78
void copyAttributesFrom(const GlobalValue *Src) override
copyAttributesFrom - copy all additional attributes (those not needed to create a GlobalVariable) fro...
Definition: Globals.cpp:221
unsigned getAlignment() const
Definition: Globals.cpp:63
A raw_ostream that writes to an std::string.
Definition: raw_ostream.h:465
static GlobalValue * copyGlobalValueProto(TypeMapTy &TypeMap, Module &DstM, const GlobalValue *SGV)
Module * getParent()
Get the module that this global value is contained inside of...
Definition: GlobalValue.h:365
LLVM Value Representation.
Definition: Value.h:69
bool hasUnnamedAddr() const
Definition: GlobalValue.h:130
static VectorType * get(Type *ElementType, unsigned NumElements)
VectorType::get - This static method is the primary way to construct an VectorType.
Definition: Type.cpp:713
void dematerialize()
If this GlobalValue is read in, and if the GVMaterializer supports it, release the memory for the fun...
Definition: Globals.cpp:41
static StructType * create(LLVMContext &Context, StringRef Name)
StructType::create - This creates an identified struct.
Definition: Type.cpp:490
virtual void eraseFromParent()=0
This method unlinks 'this' from the containing module and deletes it.
unsigned getNumOperands() const
Definition: Metadata.cpp:961
VendorType getVendor() const
getVendor - Get the parsed vendor type of this triple.
Definition: Triple.h:248
C - The default llvm calling convention, compatible with C.
Definition: CallingConv.h:34
StringRef - Represent a constant reference to a string, i.e.
Definition: StringRef.h:40
A single uniqued string.
Definition: Metadata.h:508
bool operator==(uint64_t V1, const APInt &V2)
Definition: APInt.h:1734
TypeFinder - Walk over a module, identifying all of the types that are used by the module...
Definition: TypeFinder.h:30
Root of the metadata hierarchy.
Definition: Metadata.h:45
std::error_code materialize()
Make sure this GlobalValue is fully read.
Definition: Globals.cpp:38
bool isDeclarationForLinker() const
Definition: GlobalValue.h:344
GlobalValue * getNamedValue(StringRef Name) const
Return the global value in the module with the specified name, of arbitrary type. ...
Definition: Module.cpp:88
static StructType * getTombstoneKey()
iterator end()
Definition: StringMap.h:255
void setAliasee(Constant *Aliasee)
These methods retrive and set alias target.
Definition: Globals.cpp:281
#define T1
iterator_range< arg_iterator > args()
Definition: Function.h:489
bool erase(const KeyT &Val)
Definition: ValueMap.h:168
LLVMContext & getContext() const
Get the global data context.
Definition: Module.h:265
void setPrefixData(Constant *PrefixData)
Definition: Function.cpp:935
void resize(size_type N)
Definition: SmallVector.h:376