LLVM  7.0.0svn
IRMover.cpp
Go to the documentation of this file.
1 //===- lib/Linker/IRMover.cpp ---------------------------------------------===//
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 #include "llvm/Linker/IRMover.h"
11 #include "LinkDiagnosticInfo.h"
12 #include "llvm/ADT/SetVector.h"
13 #include "llvm/ADT/SmallString.h"
14 #include "llvm/ADT/Triple.h"
15 #include "llvm/IR/Constants.h"
16 #include "llvm/IR/DebugInfo.h"
18 #include "llvm/IR/GVMaterializer.h"
19 #include "llvm/IR/Intrinsics.h"
20 #include "llvm/IR/TypeFinder.h"
21 #include "llvm/Support/Error.h"
23 #include <utility>
24 using namespace llvm;
25 
26 //===----------------------------------------------------------------------===//
27 // TypeMap implementation.
28 //===----------------------------------------------------------------------===//
29 
30 namespace {
31 class TypeMapTy : public ValueMapTypeRemapper {
32  /// This is a mapping from a source type to a destination type to use.
33  DenseMap<Type *, Type *> MappedTypes;
34 
35  /// When checking to see if two subgraphs are isomorphic, we speculatively
36  /// add types to MappedTypes, but keep track of them here in case we need to
37  /// roll back.
38  SmallVector<Type *, 16> SpeculativeTypes;
39 
40  SmallVector<StructType *, 16> SpeculativeDstOpaqueTypes;
41 
42  /// This is a list of non-opaque structs in the source module that are mapped
43  /// to an opaque struct in the destination module.
44  SmallVector<StructType *, 16> SrcDefinitionsToResolve;
45 
46  /// This is the set of opaque types in the destination modules who are
47  /// getting a body from the source module.
48  SmallPtrSet<StructType *, 16> DstResolvedOpaqueTypes;
49 
50 public:
51  TypeMapTy(IRMover::IdentifiedStructTypeSet &DstStructTypesSet)
52  : DstStructTypesSet(DstStructTypesSet) {}
53 
54  IRMover::IdentifiedStructTypeSet &DstStructTypesSet;
55  /// Indicate that the specified type in the destination module is conceptually
56  /// equivalent to the specified type in the source module.
57  void addTypeMapping(Type *DstTy, Type *SrcTy);
58 
59  /// Produce a body for an opaque type in the dest module from a type
60  /// definition in the source module.
61  void linkDefinedTypeBodies();
62 
63  /// Return the mapped type to use for the specified input type from the
64  /// source module.
65  Type *get(Type *SrcTy);
66  Type *get(Type *SrcTy, SmallPtrSet<StructType *, 8> &Visited);
67 
68  void finishType(StructType *DTy, StructType *STy, ArrayRef<Type *> ETypes);
69 
70  FunctionType *get(FunctionType *T) {
71  return cast<FunctionType>(get((Type *)T));
72  }
73 
74 private:
75  Type *remapType(Type *SrcTy) override { return get(SrcTy); }
76 
77  bool areTypesIsomorphic(Type *DstTy, Type *SrcTy);
78 };
79 }
80 
81 void TypeMapTy::addTypeMapping(Type *DstTy, Type *SrcTy) {
82  assert(SpeculativeTypes.empty());
83  assert(SpeculativeDstOpaqueTypes.empty());
84 
85  // Check to see if these types are recursively isomorphic and establish a
86  // mapping between them if so.
87  if (!areTypesIsomorphic(DstTy, SrcTy)) {
88  // Oops, they aren't isomorphic. Just discard this request by rolling out
89  // any speculative mappings we've established.
90  for (Type *Ty : SpeculativeTypes)
91  MappedTypes.erase(Ty);
92 
93  SrcDefinitionsToResolve.resize(SrcDefinitionsToResolve.size() -
94  SpeculativeDstOpaqueTypes.size());
95  for (StructType *Ty : SpeculativeDstOpaqueTypes)
96  DstResolvedOpaqueTypes.erase(Ty);
97  } else {
98  // SrcTy and DstTy are recursively ismorphic. We clear names of SrcTy
99  // and all its descendants to lower amount of renaming in LLVM context
100  // Renaming occurs because we load all source modules to the same context
101  // and declaration with existing name gets renamed (i.e Foo -> Foo.42).
102  // As a result we may get several different types in the destination
103  // module, which are in fact the same.
104  for (Type *Ty : SpeculativeTypes)
105  if (auto *STy = dyn_cast<StructType>(Ty))
106  if (STy->hasName())
107  STy->setName("");
108  }
109  SpeculativeTypes.clear();
110  SpeculativeDstOpaqueTypes.clear();
111 }
112 
113 /// Recursively walk this pair of types, returning true if they are isomorphic,
114 /// false if they are not.
115 bool TypeMapTy::areTypesIsomorphic(Type *DstTy, Type *SrcTy) {
116  // Two types with differing kinds are clearly not isomorphic.
117  if (DstTy->getTypeID() != SrcTy->getTypeID())
118  return false;
119 
120  // If we have an entry in the MappedTypes table, then we have our answer.
121  Type *&Entry = MappedTypes[SrcTy];
122  if (Entry)
123  return Entry == DstTy;
124 
125  // Two identical types are clearly isomorphic. Remember this
126  // non-speculatively.
127  if (DstTy == SrcTy) {
128  Entry = DstTy;
129  return true;
130  }
131 
132  // Okay, we have two types with identical kinds that we haven't seen before.
133 
134  // If this is an opaque struct type, special case it.
135  if (StructType *SSTy = dyn_cast<StructType>(SrcTy)) {
136  // Mapping an opaque type to any struct, just keep the dest struct.
137  if (SSTy->isOpaque()) {
138  Entry = DstTy;
139  SpeculativeTypes.push_back(SrcTy);
140  return true;
141  }
142 
143  // Mapping a non-opaque source type to an opaque dest. If this is the first
144  // type that we're mapping onto this destination type then we succeed. Keep
145  // the dest, but fill it in later. If this is the second (different) type
146  // that we're trying to map onto the same opaque type then we fail.
147  if (cast<StructType>(DstTy)->isOpaque()) {
148  // We can only map one source type onto the opaque destination type.
149  if (!DstResolvedOpaqueTypes.insert(cast<StructType>(DstTy)).second)
150  return false;
151  SrcDefinitionsToResolve.push_back(SSTy);
152  SpeculativeTypes.push_back(SrcTy);
153  SpeculativeDstOpaqueTypes.push_back(cast<StructType>(DstTy));
154  Entry = DstTy;
155  return true;
156  }
157  }
158 
159  // If the number of subtypes disagree between the two types, then we fail.
160  if (SrcTy->getNumContainedTypes() != DstTy->getNumContainedTypes())
161  return false;
162 
163  // Fail if any of the extra properties (e.g. array size) of the type disagree.
164  if (isa<IntegerType>(DstTy))
165  return false; // bitwidth disagrees.
166  if (PointerType *PT = dyn_cast<PointerType>(DstTy)) {
167  if (PT->getAddressSpace() != cast<PointerType>(SrcTy)->getAddressSpace())
168  return false;
169 
170  } else if (FunctionType *FT = dyn_cast<FunctionType>(DstTy)) {
171  if (FT->isVarArg() != cast<FunctionType>(SrcTy)->isVarArg())
172  return false;
173  } else if (StructType *DSTy = dyn_cast<StructType>(DstTy)) {
174  StructType *SSTy = cast<StructType>(SrcTy);
175  if (DSTy->isLiteral() != SSTy->isLiteral() ||
176  DSTy->isPacked() != SSTy->isPacked())
177  return false;
178  } else if (auto *DSeqTy = dyn_cast<SequentialType>(DstTy)) {
179  if (DSeqTy->getNumElements() !=
180  cast<SequentialType>(SrcTy)->getNumElements())
181  return false;
182  }
183 
184  // Otherwise, we speculate that these two types will line up and recursively
185  // check the subelements.
186  Entry = DstTy;
187  SpeculativeTypes.push_back(SrcTy);
188 
189  for (unsigned I = 0, E = SrcTy->getNumContainedTypes(); I != E; ++I)
190  if (!areTypesIsomorphic(DstTy->getContainedType(I),
191  SrcTy->getContainedType(I)))
192  return false;
193 
194  // If everything seems to have lined up, then everything is great.
195  return true;
196 }
197 
198 void TypeMapTy::linkDefinedTypeBodies() {
199  SmallVector<Type *, 16> Elements;
200  for (StructType *SrcSTy : SrcDefinitionsToResolve) {
201  StructType *DstSTy = cast<StructType>(MappedTypes[SrcSTy]);
202  assert(DstSTy->isOpaque());
203 
204  // Map the body of the source type over to a new body for the dest type.
205  Elements.resize(SrcSTy->getNumElements());
206  for (unsigned I = 0, E = Elements.size(); I != E; ++I)
207  Elements[I] = get(SrcSTy->getElementType(I));
208 
209  DstSTy->setBody(Elements, SrcSTy->isPacked());
210  DstStructTypesSet.switchToNonOpaque(DstSTy);
211  }
212  SrcDefinitionsToResolve.clear();
213  DstResolvedOpaqueTypes.clear();
214 }
215 
216 void TypeMapTy::finishType(StructType *DTy, StructType *STy,
217  ArrayRef<Type *> ETypes) {
218  DTy->setBody(ETypes, STy->isPacked());
219 
220  // Steal STy's name.
221  if (STy->hasName()) {
222  SmallString<16> TmpName = STy->getName();
223  STy->setName("");
224  DTy->setName(TmpName);
225  }
226 
227  DstStructTypesSet.addNonOpaque(DTy);
228 }
229 
230 Type *TypeMapTy::get(Type *Ty) {
232  return get(Ty, Visited);
233 }
234 
235 Type *TypeMapTy::get(Type *Ty, SmallPtrSet<StructType *, 8> &Visited) {
236  // If we already have an entry for this type, return it.
237  Type **Entry = &MappedTypes[Ty];
238  if (*Entry)
239  return *Entry;
240 
241  // These are types that LLVM itself will unique.
242  bool IsUniqued = !isa<StructType>(Ty) || cast<StructType>(Ty)->isLiteral();
243 
244 #ifndef NDEBUG
245  if (!IsUniqued) {
246  for (auto &Pair : MappedTypes) {
247  assert(!(Pair.first != Ty && Pair.second == Ty) &&
248  "mapping to a source type");
249  }
250  }
251 #endif
252 
253  if (!IsUniqued && !Visited.insert(cast<StructType>(Ty)).second) {
255  return *Entry = DTy;
256  }
257 
258  // If this is not a recursive type, then just map all of the elements and
259  // then rebuild the type from inside out.
260  SmallVector<Type *, 4> ElementTypes;
261 
262  // If there are no element types to map, then the type is itself. This is
263  // true for the anonymous {} struct, things like 'float', integers, etc.
264  if (Ty->getNumContainedTypes() == 0 && IsUniqued)
265  return *Entry = Ty;
266 
267  // Remap all of the elements, keeping track of whether any of them change.
268  bool AnyChange = false;
269  ElementTypes.resize(Ty->getNumContainedTypes());
270  for (unsigned I = 0, E = Ty->getNumContainedTypes(); I != E; ++I) {
271  ElementTypes[I] = get(Ty->getContainedType(I), Visited);
272  AnyChange |= ElementTypes[I] != Ty->getContainedType(I);
273  }
274 
275  // If we found our type while recursively processing stuff, just use it.
276  Entry = &MappedTypes[Ty];
277  if (*Entry) {
278  if (auto *DTy = dyn_cast<StructType>(*Entry)) {
279  if (DTy->isOpaque()) {
280  auto *STy = cast<StructType>(Ty);
281  finishType(DTy, STy, ElementTypes);
282  }
283  }
284  return *Entry;
285  }
286 
287  // If all of the element types mapped directly over and the type is not
288  // a named struct, then the type is usable as-is.
289  if (!AnyChange && IsUniqued)
290  return *Entry = Ty;
291 
292  // Otherwise, rebuild a modified type.
293  switch (Ty->getTypeID()) {
294  default:
295  llvm_unreachable("unknown derived type to remap");
296  case Type::ArrayTyID:
297  return *Entry = ArrayType::get(ElementTypes[0],
298  cast<ArrayType>(Ty)->getNumElements());
299  case Type::VectorTyID:
300  return *Entry = VectorType::get(ElementTypes[0],
301  cast<VectorType>(Ty)->getNumElements());
302  case Type::PointerTyID:
303  return *Entry = PointerType::get(ElementTypes[0],
304  cast<PointerType>(Ty)->getAddressSpace());
305  case Type::FunctionTyID:
306  return *Entry = FunctionType::get(ElementTypes[0],
307  makeArrayRef(ElementTypes).slice(1),
308  cast<FunctionType>(Ty)->isVarArg());
309  case Type::StructTyID: {
310  auto *STy = cast<StructType>(Ty);
311  bool IsPacked = STy->isPacked();
312  if (IsUniqued)
313  return *Entry = StructType::get(Ty->getContext(), ElementTypes, IsPacked);
314 
315  // If the type is opaque, we can just use it directly.
316  if (STy->isOpaque()) {
317  DstStructTypesSet.addOpaque(STy);
318  return *Entry = Ty;
319  }
320 
321  if (StructType *OldT =
322  DstStructTypesSet.findNonOpaque(ElementTypes, IsPacked)) {
323  STy->setName("");
324  return *Entry = OldT;
325  }
326 
327  if (!AnyChange) {
328  DstStructTypesSet.addNonOpaque(STy);
329  return *Entry = Ty;
330  }
331 
333  finishType(DTy, STy, ElementTypes);
334  return *Entry = DTy;
335  }
336  }
337 }
338 
340  const Twine &Msg)
341  : DiagnosticInfo(DK_Linker, Severity), Msg(Msg) {}
342 void LinkDiagnosticInfo::print(DiagnosticPrinter &DP) const { DP << Msg; }
343 
344 //===----------------------------------------------------------------------===//
345 // IRLinker implementation.
346 //===----------------------------------------------------------------------===//
347 
348 namespace {
349 class IRLinker;
350 
351 /// Creates prototypes for functions that are lazily linked on the fly. This
352 /// speeds up linking for modules with many/ lazily linked functions of which
353 /// few get used.
354 class GlobalValueMaterializer final : public ValueMaterializer {
355  IRLinker &TheIRLinker;
356 
357 public:
358  GlobalValueMaterializer(IRLinker &TheIRLinker) : TheIRLinker(TheIRLinker) {}
359  Value *materialize(Value *V) override;
360 };
361 
362 class LocalValueMaterializer final : public ValueMaterializer {
363  IRLinker &TheIRLinker;
364 
365 public:
366  LocalValueMaterializer(IRLinker &TheIRLinker) : TheIRLinker(TheIRLinker) {}
367  Value *materialize(Value *V) override;
368 };
369 
370 /// Type of the Metadata map in \a ValueToValueMapTy.
372 
373 /// This is responsible for keeping track of the state used for moving data
374 /// from SrcM to DstM.
375 class IRLinker {
376  Module &DstM;
377  std::unique_ptr<Module> SrcM;
378 
379  /// See IRMover::move().
380  std::function<void(GlobalValue &, IRMover::ValueAdder)> AddLazyFor;
381 
382  TypeMapTy TypeMap;
383  GlobalValueMaterializer GValMaterializer;
384  LocalValueMaterializer LValMaterializer;
385 
386  /// A metadata map that's shared between IRLinker instances.
387  MDMapT &SharedMDs;
388 
389  /// Mapping of values from what they used to be in Src, to what they are now
390  /// in DstM. ValueToValueMapTy is a ValueMap, which involves some overhead
391  /// due to the use of Value handles which the Linker doesn't actually need,
392  /// but this allows us to reuse the ValueMapper code.
394  ValueToValueMapTy AliasValueMap;
395 
396  DenseSet<GlobalValue *> ValuesToLink;
397  std::vector<GlobalValue *> Worklist;
398 
399  void maybeAdd(GlobalValue *GV) {
400  if (ValuesToLink.insert(GV).second)
401  Worklist.push_back(GV);
402  }
403 
404  /// Whether we are importing globals for ThinLTO, as opposed to linking the
405  /// source module. If this flag is set, it means that we can rely on some
406  /// other object file to define any non-GlobalValue entities defined by the
407  /// source module. This currently causes us to not link retained types in
408  /// debug info metadata and module inline asm.
409  bool IsPerformingImport;
410 
411  /// Set to true when all global value body linking is complete (including
412  /// lazy linking). Used to prevent metadata linking from creating new
413  /// references.
414  bool DoneLinkingBodies = false;
415 
416  /// The Error encountered during materialization. We use an Optional here to
417  /// avoid needing to manage an unconsumed success value.
418  Optional<Error> FoundError;
419  void setError(Error E) {
420  if (E)
421  FoundError = std::move(E);
422  }
423 
424  /// Most of the errors produced by this module are inconvertible StringErrors.
425  /// This convenience function lets us return one of those more easily.
426  Error stringErr(const Twine &T) {
427  return make_error<StringError>(T, inconvertibleErrorCode());
428  }
429 
430  /// Entry point for mapping values and alternate context for mapping aliases.
431  ValueMapper Mapper;
432  unsigned AliasMCID;
433 
434  /// Handles cloning of a global values from the source module into
435  /// the destination module, including setting the attributes and visibility.
436  GlobalValue *copyGlobalValueProto(const GlobalValue *SGV, bool ForDefinition);
437 
438  void emitWarning(const Twine &Message) {
439  SrcM->getContext().diagnose(LinkDiagnosticInfo(DS_Warning, Message));
440  }
441 
442  /// Given a global in the source module, return the global in the
443  /// destination module that is being linked to, if any.
444  GlobalValue *getLinkedToGlobal(const GlobalValue *SrcGV) {
445  // If the source has no name it can't link. If it has local linkage,
446  // there is no name match-up going on.
447  if (!SrcGV->hasName() || SrcGV->hasLocalLinkage())
448  return nullptr;
449 
450  // Otherwise see if we have a match in the destination module's symtab.
451  GlobalValue *DGV = DstM.getNamedValue(SrcGV->getName());
452  if (!DGV)
453  return nullptr;
454 
455  // If we found a global with the same name in the dest module, but it has
456  // internal linkage, we are really not doing any linkage here.
457  if (DGV->hasLocalLinkage())
458  return nullptr;
459 
460  // Otherwise, we do in fact link to the destination global.
461  return DGV;
462  }
463 
464  void computeTypeMapping();
465 
466  Expected<Constant *> linkAppendingVarProto(GlobalVariable *DstGV,
467  const GlobalVariable *SrcGV);
468 
469  /// Given the GlobaValue \p SGV in the source module, and the matching
470  /// GlobalValue \p DGV (if any), return true if the linker will pull \p SGV
471  /// into the destination module.
472  ///
473  /// Note this code may call the client-provided \p AddLazyFor.
474  bool shouldLink(GlobalValue *DGV, GlobalValue &SGV);
475  Expected<Constant *> linkGlobalValueProto(GlobalValue *GV, bool ForAlias);
476 
477  Error linkModuleFlagsMetadata();
478 
479  void linkGlobalVariable(GlobalVariable &Dst, GlobalVariable &Src);
480  Error linkFunctionBody(Function &Dst, Function &Src);
481  void linkAliasBody(GlobalAlias &Dst, GlobalAlias &Src);
482  Error linkGlobalValueBody(GlobalValue &Dst, GlobalValue &Src);
483 
484  /// Functions that take care of cloning a specific global value type
485  /// into the destination module.
486  GlobalVariable *copyGlobalVariableProto(const GlobalVariable *SGVar);
487  Function *copyFunctionProto(const Function *SF);
488  GlobalValue *copyGlobalAliasProto(const GlobalAlias *SGA);
489 
490  /// When importing for ThinLTO, prevent importing of types listed on
491  /// the DICompileUnit that we don't need a copy of in the importing
492  /// module.
493  void prepareCompileUnitsForImport();
494  void linkNamedMDNodes();
495 
496 public:
497  IRLinker(Module &DstM, MDMapT &SharedMDs,
498  IRMover::IdentifiedStructTypeSet &Set, std::unique_ptr<Module> SrcM,
499  ArrayRef<GlobalValue *> ValuesToLink,
500  std::function<void(GlobalValue &, IRMover::ValueAdder)> AddLazyFor,
501  bool IsPerformingImport)
502  : DstM(DstM), SrcM(std::move(SrcM)), AddLazyFor(std::move(AddLazyFor)),
503  TypeMap(Set), GValMaterializer(*this), LValMaterializer(*this),
504  SharedMDs(SharedMDs), IsPerformingImport(IsPerformingImport),
505  Mapper(ValueMap, RF_MoveDistinctMDs | RF_IgnoreMissingLocals, &TypeMap,
506  &GValMaterializer),
507  AliasMCID(Mapper.registerAlternateMappingContext(AliasValueMap,
508  &LValMaterializer)) {
509  ValueMap.getMDMap() = std::move(SharedMDs);
510  for (GlobalValue *GV : ValuesToLink)
511  maybeAdd(GV);
512  if (IsPerformingImport)
513  prepareCompileUnitsForImport();
514  }
515  ~IRLinker() { SharedMDs = std::move(*ValueMap.getMDMap()); }
516 
517  Error run();
518  Value *materialize(Value *V, bool ForAlias);
519 };
520 }
521 
522 /// The LLVM SymbolTable class autorenames globals that conflict in the symbol
523 /// table. This is good for all clients except for us. Go through the trouble
524 /// to force this back.
526  // If the global doesn't force its name or if it already has the right name,
527  // there is nothing for us to do.
528  if (GV->hasLocalLinkage() || GV->getName() == Name)
529  return;
530 
531  Module *M = GV->getParent();
532 
533  // If there is a conflict, rename the conflict.
534  if (GlobalValue *ConflictGV = M->getNamedValue(Name)) {
535  GV->takeName(ConflictGV);
536  ConflictGV->setName(Name); // This will cause ConflictGV to get renamed
537  assert(ConflictGV->getName() != Name && "forceRenaming didn't work");
538  } else {
539  GV->setName(Name); // Force the name back
540  }
541 }
542 
543 Value *GlobalValueMaterializer::materialize(Value *SGV) {
544  return TheIRLinker.materialize(SGV, false);
545 }
546 
547 Value *LocalValueMaterializer::materialize(Value *SGV) {
548  return TheIRLinker.materialize(SGV, true);
549 }
550 
551 Value *IRLinker::materialize(Value *V, bool ForAlias) {
552  auto *SGV = dyn_cast<GlobalValue>(V);
553  if (!SGV)
554  return nullptr;
555 
556  Expected<Constant *> NewProto = linkGlobalValueProto(SGV, ForAlias);
557  if (!NewProto) {
558  setError(NewProto.takeError());
559  return nullptr;
560  }
561  if (!*NewProto)
562  return nullptr;
563 
564  GlobalValue *New = dyn_cast<GlobalValue>(*NewProto);
565  if (!New)
566  return *NewProto;
567 
568  // If we already created the body, just return.
569  if (auto *F = dyn_cast<Function>(New)) {
570  if (!F->isDeclaration())
571  return New;
572  } else if (auto *V = dyn_cast<GlobalVariable>(New)) {
573  if (V->hasInitializer() || V->hasAppendingLinkage())
574  return New;
575  } else {
576  auto *A = cast<GlobalAlias>(New);
577  if (A->getAliasee())
578  return New;
579  }
580 
581  // When linking a global for an alias, it will always be linked. However we
582  // need to check if it was not already scheduled to satisfy a reference from a
583  // regular global value initializer. We know if it has been schedule if the
584  // "New" GlobalValue that is mapped here for the alias is the same as the one
585  // already mapped. If there is an entry in the ValueMap but the value is
586  // different, it means that the value already had a definition in the
587  // destination module (linkonce for instance), but we need a new definition
588  // for the alias ("New" will be different.
589  if (ForAlias && ValueMap.lookup(SGV) == New)
590  return New;
591 
592  if (ForAlias || shouldLink(New, *SGV))
593  setError(linkGlobalValueBody(*New, *SGV));
594 
595  return New;
596 }
597 
598 /// Loop through the global variables in the src module and merge them into the
599 /// dest module.
600 GlobalVariable *IRLinker::copyGlobalVariableProto(const GlobalVariable *SGVar) {
601  // No linking to be performed or linking from the source: simply create an
602  // identical version of the symbol over in the dest module... the
603  // initializer will be filled in later by LinkGlobalInits.
604  GlobalVariable *NewDGV =
605  new GlobalVariable(DstM, TypeMap.get(SGVar->getValueType()),
607  /*init*/ nullptr, SGVar->getName(),
608  /*insertbefore*/ nullptr, SGVar->getThreadLocalMode(),
609  SGVar->getType()->getAddressSpace());
610  NewDGV->setAlignment(SGVar->getAlignment());
611  NewDGV->copyAttributesFrom(SGVar);
612  return NewDGV;
613 }
614 
615 /// Link the function in the source module into the destination module if
616 /// needed, setting up mapping information.
617 Function *IRLinker::copyFunctionProto(const Function *SF) {
618  // If there is no linkage to be performed or we are linking from the source,
619  // bring SF over.
620  auto *F =
621  Function::Create(TypeMap.get(SF->getFunctionType()),
622  GlobalValue::ExternalLinkage, SF->getName(), &DstM);
623  F->copyAttributesFrom(SF);
624  return F;
625 }
626 
627 /// Set up prototypes for any aliases that come over from the source module.
628 GlobalValue *IRLinker::copyGlobalAliasProto(const GlobalAlias *SGA) {
629  // If there is no linkage to be performed or we're linking from the source,
630  // bring over SGA.
631  auto *Ty = TypeMap.get(SGA->getValueType());
632  auto *GA =
634  GlobalValue::ExternalLinkage, SGA->getName(), &DstM);
635  GA->copyAttributesFrom(SGA);
636  return GA;
637 }
638 
639 GlobalValue *IRLinker::copyGlobalValueProto(const GlobalValue *SGV,
640  bool ForDefinition) {
641  GlobalValue *NewGV;
642  if (auto *SGVar = dyn_cast<GlobalVariable>(SGV)) {
643  NewGV = copyGlobalVariableProto(SGVar);
644  } else if (auto *SF = dyn_cast<Function>(SGV)) {
645  NewGV = copyFunctionProto(SF);
646  } else {
647  if (ForDefinition)
648  NewGV = copyGlobalAliasProto(cast<GlobalAlias>(SGV));
649  else if (SGV->getValueType()->isFunctionTy())
650  NewGV =
651  Function::Create(cast<FunctionType>(TypeMap.get(SGV->getValueType())),
652  GlobalValue::ExternalLinkage, SGV->getName(), &DstM);
653  else
654  NewGV = new GlobalVariable(
655  DstM, TypeMap.get(SGV->getValueType()),
656  /*isConstant*/ false, GlobalValue::ExternalLinkage,
657  /*init*/ nullptr, SGV->getName(),
658  /*insertbefore*/ nullptr, SGV->getThreadLocalMode(),
659  SGV->getType()->getAddressSpace());
660  }
661 
662  if (ForDefinition)
663  NewGV->setLinkage(SGV->getLinkage());
664  else if (SGV->hasExternalWeakLinkage())
666 
667  if (auto *NewGO = dyn_cast<GlobalObject>(NewGV)) {
668  // Metadata for global variables and function declarations is copied eagerly.
669  if (isa<GlobalVariable>(SGV) || SGV->isDeclaration())
670  NewGO->copyMetadata(cast<GlobalObject>(SGV), 0);
671  }
672 
673  // Remove these copied constants in case this stays a declaration, since
674  // they point to the source module. If the def is linked the values will
675  // be mapped in during linkFunctionBody.
676  if (auto *NewF = dyn_cast<Function>(NewGV)) {
677  NewF->setPersonalityFn(nullptr);
678  NewF->setPrefixData(nullptr);
679  NewF->setPrologueData(nullptr);
680  }
681 
682  return NewGV;
683 }
684 
686  size_t DotPos = Name.rfind('.');
687  return (DotPos == 0 || DotPos == StringRef::npos || Name.back() == '.' ||
688  !isdigit(static_cast<unsigned char>(Name[DotPos + 1])))
689  ? Name
690  : Name.substr(0, DotPos);
691 }
692 
693 /// Loop over all of the linked values to compute type mappings. For example,
694 /// if we link "extern Foo *x" and "Foo *x = NULL", then we have two struct
695 /// types 'Foo' but one got renamed when the module was loaded into the same
696 /// LLVMContext.
697 void IRLinker::computeTypeMapping() {
698  for (GlobalValue &SGV : SrcM->globals()) {
699  GlobalValue *DGV = getLinkedToGlobal(&SGV);
700  if (!DGV)
701  continue;
702 
703  if (!DGV->hasAppendingLinkage() || !SGV.hasAppendingLinkage()) {
704  TypeMap.addTypeMapping(DGV->getType(), SGV.getType());
705  continue;
706  }
707 
708  // Unify the element type of appending arrays.
709  ArrayType *DAT = cast<ArrayType>(DGV->getValueType());
710  ArrayType *SAT = cast<ArrayType>(SGV.getValueType());
711  TypeMap.addTypeMapping(DAT->getElementType(), SAT->getElementType());
712  }
713 
714  for (GlobalValue &SGV : *SrcM)
715  if (GlobalValue *DGV = getLinkedToGlobal(&SGV))
716  TypeMap.addTypeMapping(DGV->getType(), SGV.getType());
717 
718  for (GlobalValue &SGV : SrcM->aliases())
719  if (GlobalValue *DGV = getLinkedToGlobal(&SGV))
720  TypeMap.addTypeMapping(DGV->getType(), SGV.getType());
721 
722  // Incorporate types by name, scanning all the types in the source module.
723  // At this point, the destination module may have a type "%foo = { i32 }" for
724  // example. When the source module got loaded into the same LLVMContext, if
725  // it had the same type, it would have been renamed to "%foo.42 = { i32 }".
726  std::vector<StructType *> Types = SrcM->getIdentifiedStructTypes();
727  for (StructType *ST : Types) {
728  if (!ST->hasName())
729  continue;
730 
731  if (TypeMap.DstStructTypesSet.hasType(ST)) {
732  // This is actually a type from the destination module.
733  // getIdentifiedStructTypes() can have found it by walking debug info
734  // metadata nodes, some of which get linked by name when ODR Type Uniquing
735  // is enabled on the Context, from the source to the destination module.
736  continue;
737  }
738 
739  auto STTypePrefix = getTypeNamePrefix(ST->getName());
740  if (STTypePrefix.size()== ST->getName().size())
741  continue;
742 
743  // Check to see if the destination module has a struct with the prefix name.
744  StructType *DST = DstM.getTypeByName(STTypePrefix);
745  if (!DST)
746  continue;
747 
748  // Don't use it if this actually came from the source module. They're in
749  // the same LLVMContext after all. Also don't use it unless the type is
750  // actually used in the destination module. This can happen in situations
751  // like this:
752  //
753  // Module A Module B
754  // -------- --------
755  // %Z = type { %A } %B = type { %C.1 }
756  // %A = type { %B.1, [7 x i8] } %C.1 = type { i8* }
757  // %B.1 = type { %C } %A.2 = type { %B.3, [5 x i8] }
758  // %C = type { i8* } %B.3 = type { %C.1 }
759  //
760  // When we link Module B with Module A, the '%B' in Module B is
761  // used. However, that would then use '%C.1'. But when we process '%C.1',
762  // we prefer to take the '%C' version. So we are then left with both
763  // '%C.1' and '%C' being used for the same types. This leads to some
764  // variables using one type and some using the other.
765  if (TypeMap.DstStructTypesSet.hasType(DST))
766  TypeMap.addTypeMapping(DST, ST);
767  }
768 
769  // Now that we have discovered all of the type equivalences, get a body for
770  // any 'opaque' types in the dest module that are now resolved.
771  TypeMap.linkDefinedTypeBodies();
772 }
773 
774 static void getArrayElements(const Constant *C,
776  unsigned NumElements = cast<ArrayType>(C->getType())->getNumElements();
777 
778  for (unsigned i = 0; i != NumElements; ++i)
779  Dest.push_back(C->getAggregateElement(i));
780 }
781 
782 /// If there were any appending global variables, link them together now.
784 IRLinker::linkAppendingVarProto(GlobalVariable *DstGV,
785  const GlobalVariable *SrcGV) {
786  Type *EltTy = cast<ArrayType>(TypeMap.get(SrcGV->getValueType()))
787  ->getElementType();
788 
789  // FIXME: This upgrade is done during linking to support the C API. Once the
790  // old form is deprecated, we should move this upgrade to
791  // llvm::UpgradeGlobalVariable() and simplify the logic here and in
792  // Mapper::mapAppendingVariable() in ValueMapper.cpp.
793  StringRef Name = SrcGV->getName();
794  bool IsNewStructor = false;
795  bool IsOldStructor = false;
796  if (Name == "llvm.global_ctors" || Name == "llvm.global_dtors") {
797  if (cast<StructType>(EltTy)->getNumElements() == 3)
798  IsNewStructor = true;
799  else
800  IsOldStructor = true;
801  }
802 
803  PointerType *VoidPtrTy = Type::getInt8Ty(SrcGV->getContext())->getPointerTo();
804  if (IsOldStructor) {
805  auto &ST = *cast<StructType>(EltTy);
806  Type *Tys[3] = {ST.getElementType(0), ST.getElementType(1), VoidPtrTy};
807  EltTy = StructType::get(SrcGV->getContext(), Tys, false);
808  }
809 
810  uint64_t DstNumElements = 0;
811  if (DstGV) {
812  ArrayType *DstTy = cast<ArrayType>(DstGV->getValueType());
813  DstNumElements = DstTy->getNumElements();
814 
815  if (!SrcGV->hasAppendingLinkage() || !DstGV->hasAppendingLinkage())
816  return stringErr(
817  "Linking globals named '" + SrcGV->getName() +
818  "': can only link appending global with another appending "
819  "global!");
820 
821  // Check to see that they two arrays agree on type.
822  if (EltTy != DstTy->getElementType())
823  return stringErr("Appending variables with different element types!");
824  if (DstGV->isConstant() != SrcGV->isConstant())
825  return stringErr("Appending variables linked with different const'ness!");
826 
827  if (DstGV->getAlignment() != SrcGV->getAlignment())
828  return stringErr(
829  "Appending variables with different alignment need to be linked!");
830 
831  if (DstGV->getVisibility() != SrcGV->getVisibility())
832  return stringErr(
833  "Appending variables with different visibility need to be linked!");
834 
835  if (DstGV->hasGlobalUnnamedAddr() != SrcGV->hasGlobalUnnamedAddr())
836  return stringErr(
837  "Appending variables with different unnamed_addr need to be linked!");
838 
839  if (DstGV->getSection() != SrcGV->getSection())
840  return stringErr(
841  "Appending variables with different section name need to be linked!");
842  }
843 
844  SmallVector<Constant *, 16> SrcElements;
845  getArrayElements(SrcGV->getInitializer(), SrcElements);
846 
847  if (IsNewStructor) {
848  auto It = remove_if(SrcElements, [this](Constant *E) {
849  auto *Key =
851  if (!Key)
852  return false;
853  GlobalValue *DGV = getLinkedToGlobal(Key);
854  return !shouldLink(DGV, *Key);
855  });
856  SrcElements.erase(It, SrcElements.end());
857  }
858  uint64_t NewSize = DstNumElements + SrcElements.size();
859  ArrayType *NewType = ArrayType::get(EltTy, NewSize);
860 
861  // Create the new global variable.
862  GlobalVariable *NG = new GlobalVariable(
863  DstM, NewType, SrcGV->isConstant(), SrcGV->getLinkage(),
864  /*init*/ nullptr, /*name*/ "", DstGV, SrcGV->getThreadLocalMode(),
865  SrcGV->getType()->getAddressSpace());
866 
867  NG->copyAttributesFrom(SrcGV);
868  forceRenaming(NG, SrcGV->getName());
869 
870  Constant *Ret = ConstantExpr::getBitCast(NG, TypeMap.get(SrcGV->getType()));
871 
872  Mapper.scheduleMapAppendingVariable(*NG,
873  DstGV ? DstGV->getInitializer() : nullptr,
874  IsOldStructor, SrcElements);
875 
876  // Replace any uses of the two global variables with uses of the new
877  // global.
878  if (DstGV) {
880  DstGV->eraseFromParent();
881  }
882 
883  return Ret;
884 }
885 
886 bool IRLinker::shouldLink(GlobalValue *DGV, GlobalValue &SGV) {
887  if (ValuesToLink.count(&SGV) || SGV.hasLocalLinkage())
888  return true;
889 
890  if (DGV && !DGV->isDeclarationForLinker())
891  return false;
892 
893  if (SGV.isDeclaration() || DoneLinkingBodies)
894  return false;
895 
896  // Callback to the client to give a chance to lazily add the Global to the
897  // list of value to link.
898  bool LazilyAdded = false;
899  AddLazyFor(SGV, [this, &LazilyAdded](GlobalValue &GV) {
900  maybeAdd(&GV);
901  LazilyAdded = true;
902  });
903  return LazilyAdded;
904 }
905 
906 Expected<Constant *> IRLinker::linkGlobalValueProto(GlobalValue *SGV,
907  bool ForAlias) {
908  GlobalValue *DGV = getLinkedToGlobal(SGV);
909 
910  bool ShouldLink = shouldLink(DGV, *SGV);
911 
912  // just missing from map
913  if (ShouldLink) {
914  auto I = ValueMap.find(SGV);
915  if (I != ValueMap.end())
916  return cast<Constant>(I->second);
917 
918  I = AliasValueMap.find(SGV);
919  if (I != AliasValueMap.end())
920  return cast<Constant>(I->second);
921  }
922 
923  if (!ShouldLink && ForAlias)
924  DGV = nullptr;
925 
926  // Handle the ultra special appending linkage case first.
927  assert(!DGV || SGV->hasAppendingLinkage() == DGV->hasAppendingLinkage());
928  if (SGV->hasAppendingLinkage())
929  return linkAppendingVarProto(cast_or_null<GlobalVariable>(DGV),
930  cast<GlobalVariable>(SGV));
931 
932  GlobalValue *NewGV;
933  if (DGV && !ShouldLink) {
934  NewGV = DGV;
935  } else {
936  // If we are done linking global value bodies (i.e. we are performing
937  // metadata linking), don't link in the global value due to this
938  // reference, simply map it to null.
939  if (DoneLinkingBodies)
940  return nullptr;
941 
942  NewGV = copyGlobalValueProto(SGV, ShouldLink);
943  if (ShouldLink || !ForAlias)
944  forceRenaming(NewGV, SGV->getName());
945  }
946 
947  // Overloaded intrinsics have overloaded types names as part of their
948  // names. If we renamed overloaded types we should rename the intrinsic
949  // as well.
950  if (Function *F = dyn_cast<Function>(NewGV))
951  if (auto Remangled = Intrinsic::remangleIntrinsicFunction(F))
952  NewGV = Remangled.getValue();
953 
954  if (ShouldLink || ForAlias) {
955  if (const Comdat *SC = SGV->getComdat()) {
956  if (auto *GO = dyn_cast<GlobalObject>(NewGV)) {
957  Comdat *DC = DstM.getOrInsertComdat(SC->getName());
958  DC->setSelectionKind(SC->getSelectionKind());
959  GO->setComdat(DC);
960  }
961  }
962  }
963 
964  if (!ShouldLink && ForAlias)
966 
967  Constant *C = NewGV;
968  // Only create a bitcast if necessary. In particular, with
969  // DebugTypeODRUniquing we may reach metadata in the destination module
970  // containing a GV from the source module, in which case SGV will be
971  // the same as DGV and NewGV, and TypeMap.get() will assert since it
972  // assumes it is being invoked on a type in the source module.
973  if (DGV && NewGV != SGV)
974  C = ConstantExpr::getBitCast(NewGV, TypeMap.get(SGV->getType()));
975 
976  if (DGV && NewGV != DGV) {
978  DGV->eraseFromParent();
979  }
980 
981  return C;
982 }
983 
984 /// Update the initializers in the Dest module now that all globals that may be
985 /// referenced are in Dest.
986 void IRLinker::linkGlobalVariable(GlobalVariable &Dst, GlobalVariable &Src) {
987  // Figure out what the initializer looks like in the dest module.
988  Mapper.scheduleMapGlobalInitializer(Dst, *Src.getInitializer());
989 }
990 
991 /// Copy the source function over into the dest function and fix up references
992 /// to values. At this point we know that Dest is an external function, and
993 /// that Src is not.
994 Error IRLinker::linkFunctionBody(Function &Dst, Function &Src) {
995  assert(Dst.isDeclaration() && !Src.isDeclaration());
996 
997  // Materialize if needed.
998  if (Error Err = Src.materialize())
999  return Err;
1000 
1001  // Link in the operands without remapping.
1002  if (Src.hasPrefixData())
1003  Dst.setPrefixData(Src.getPrefixData());
1004  if (Src.hasPrologueData())
1005  Dst.setPrologueData(Src.getPrologueData());
1006  if (Src.hasPersonalityFn())
1008 
1009  // Copy over the metadata attachments without remapping.
1010  Dst.copyMetadata(&Src, 0);
1011 
1012  // Steal arguments and splice the body of Src into Dst.
1013  Dst.stealArgumentListFrom(Src);
1014  Dst.getBasicBlockList().splice(Dst.end(), Src.getBasicBlockList());
1015 
1016  // Everything has been moved over. Remap it.
1017  Mapper.scheduleRemapFunction(Dst);
1018  return Error::success();
1019 }
1020 
1021 void IRLinker::linkAliasBody(GlobalAlias &Dst, GlobalAlias &Src) {
1022  Mapper.scheduleMapGlobalAliasee(Dst, *Src.getAliasee(), AliasMCID);
1023 }
1024 
1025 Error IRLinker::linkGlobalValueBody(GlobalValue &Dst, GlobalValue &Src) {
1026  if (auto *F = dyn_cast<Function>(&Src))
1027  return linkFunctionBody(cast<Function>(Dst), *F);
1028  if (auto *GVar = dyn_cast<GlobalVariable>(&Src)) {
1029  linkGlobalVariable(cast<GlobalVariable>(Dst), *GVar);
1030  return Error::success();
1031  }
1032  linkAliasBody(cast<GlobalAlias>(Dst), cast<GlobalAlias>(Src));
1033  return Error::success();
1034 }
1035 
1036 void IRLinker::prepareCompileUnitsForImport() {
1037  NamedMDNode *SrcCompileUnits = SrcM->getNamedMetadata("llvm.dbg.cu");
1038  if (!SrcCompileUnits)
1039  return;
1040  // When importing for ThinLTO, prevent importing of types listed on
1041  // the DICompileUnit that we don't need a copy of in the importing
1042  // module. They will be emitted by the originating module.
1043  for (unsigned I = 0, E = SrcCompileUnits->getNumOperands(); I != E; ++I) {
1044  auto *CU = cast<DICompileUnit>(SrcCompileUnits->getOperand(I));
1045  assert(CU && "Expected valid compile unit");
1046  // Enums, macros, and retained types don't need to be listed on the
1047  // imported DICompileUnit. This means they will only be imported
1048  // if reached from the mapped IR. Do this by setting their value map
1049  // entries to nullptr, which will automatically prevent their importing
1050  // when reached from the DICompileUnit during metadata mapping.
1051  ValueMap.MD()[CU->getRawEnumTypes()].reset(nullptr);
1052  ValueMap.MD()[CU->getRawMacros()].reset(nullptr);
1053  ValueMap.MD()[CU->getRawRetainedTypes()].reset(nullptr);
1054  // We import global variables only temporarily in order for instcombine
1055  // and globalopt to perform constant folding and static constructor
1056  // evaluation. After that elim-avail-extern will covert imported globals
1057  // back to declarations, so we don't need debug info for them.
1058  ValueMap.MD()[CU->getRawGlobalVariables()].reset(nullptr);
1059 
1060  // Imported entities only need to be mapped in if they have local
1061  // scope, as those might correspond to an imported entity inside a
1062  // function being imported (any locally scoped imported entities that
1063  // don't end up referenced by an imported function will not be emitted
1064  // into the object). Imported entities not in a local scope
1065  // (e.g. on the namespace) only need to be emitted by the originating
1066  // module. Create a list of the locally scoped imported entities, and
1067  // replace the source CUs imported entity list with the new list, so
1068  // only those are mapped in.
1069  // FIXME: Locally-scoped imported entities could be moved to the
1070  // functions they are local to instead of listing them on the CU, and
1071  // we would naturally only link in those needed by function importing.
1072  SmallVector<TrackingMDNodeRef, 4> AllImportedModules;
1073  bool ReplaceImportedEntities = false;
1074  for (auto *IE : CU->getImportedEntities()) {
1075  DIScope *Scope = IE->getScope();
1076  assert(Scope && "Invalid Scope encoding!");
1077  if (isa<DILocalScope>(Scope))
1078  AllImportedModules.emplace_back(IE);
1079  else
1080  ReplaceImportedEntities = true;
1081  }
1082  if (ReplaceImportedEntities) {
1083  if (!AllImportedModules.empty())
1084  CU->replaceImportedEntities(MDTuple::get(
1085  CU->getContext(),
1086  SmallVector<Metadata *, 16>(AllImportedModules.begin(),
1087  AllImportedModules.end())));
1088  else
1089  // If there were no local scope imported entities, we can map
1090  // the whole list to nullptr.
1091  ValueMap.MD()[CU->getRawImportedEntities()].reset(nullptr);
1092  }
1093  }
1094 }
1095 
1096 /// Insert all of the named MDNodes in Src into the Dest module.
1097 void IRLinker::linkNamedMDNodes() {
1098  const NamedMDNode *SrcModFlags = SrcM->getModuleFlagsMetadata();
1099  for (const NamedMDNode &NMD : SrcM->named_metadata()) {
1100  // Don't link module flags here. Do them separately.
1101  if (&NMD == SrcModFlags)
1102  continue;
1103  NamedMDNode *DestNMD = DstM.getOrInsertNamedMetadata(NMD.getName());
1104  // Add Src elements into Dest node.
1105  for (const MDNode *Op : NMD.operands())
1106  DestNMD->addOperand(Mapper.mapMDNode(*Op));
1107  }
1108 }
1109 
1110 /// Merge the linker flags in Src into the Dest module.
1111 Error IRLinker::linkModuleFlagsMetadata() {
1112  // If the source module has no module flags, we are done.
1113  const NamedMDNode *SrcModFlags = SrcM->getModuleFlagsMetadata();
1114  if (!SrcModFlags)
1115  return Error::success();
1116 
1117  // If the destination module doesn't have module flags yet, then just copy
1118  // over the source module's flags.
1119  NamedMDNode *DstModFlags = DstM.getOrInsertModuleFlagsMetadata();
1120  if (DstModFlags->getNumOperands() == 0) {
1121  for (unsigned I = 0, E = SrcModFlags->getNumOperands(); I != E; ++I)
1122  DstModFlags->addOperand(SrcModFlags->getOperand(I));
1123 
1124  return Error::success();
1125  }
1126 
1127  // First build a map of the existing module flags and requirements.
1129  SmallSetVector<MDNode *, 16> Requirements;
1130  for (unsigned I = 0, E = DstModFlags->getNumOperands(); I != E; ++I) {
1131  MDNode *Op = DstModFlags->getOperand(I);
1132  ConstantInt *Behavior = mdconst::extract<ConstantInt>(Op->getOperand(0));
1133  MDString *ID = cast<MDString>(Op->getOperand(1));
1134 
1135  if (Behavior->getZExtValue() == Module::Require) {
1136  Requirements.insert(cast<MDNode>(Op->getOperand(2)));
1137  } else {
1138  Flags[ID] = std::make_pair(Op, I);
1139  }
1140  }
1141 
1142  // Merge in the flags from the source module, and also collect its set of
1143  // requirements.
1144  for (unsigned I = 0, E = SrcModFlags->getNumOperands(); I != E; ++I) {
1145  MDNode *SrcOp = SrcModFlags->getOperand(I);
1146  ConstantInt *SrcBehavior =
1147  mdconst::extract<ConstantInt>(SrcOp->getOperand(0));
1148  MDString *ID = cast<MDString>(SrcOp->getOperand(1));
1149  MDNode *DstOp;
1150  unsigned DstIndex;
1151  std::tie(DstOp, DstIndex) = Flags.lookup(ID);
1152  unsigned SrcBehaviorValue = SrcBehavior->getZExtValue();
1153 
1154  // If this is a requirement, add it and continue.
1155  if (SrcBehaviorValue == Module::Require) {
1156  // If the destination module does not already have this requirement, add
1157  // it.
1158  if (Requirements.insert(cast<MDNode>(SrcOp->getOperand(2)))) {
1159  DstModFlags->addOperand(SrcOp);
1160  }
1161  continue;
1162  }
1163 
1164  // If there is no existing flag with this ID, just add it.
1165  if (!DstOp) {
1166  Flags[ID] = std::make_pair(SrcOp, DstModFlags->getNumOperands());
1167  DstModFlags->addOperand(SrcOp);
1168  continue;
1169  }
1170 
1171  // Otherwise, perform a merge.
1172  ConstantInt *DstBehavior =
1173  mdconst::extract<ConstantInt>(DstOp->getOperand(0));
1174  unsigned DstBehaviorValue = DstBehavior->getZExtValue();
1175 
1176  auto overrideDstValue = [&]() {
1177  DstModFlags->setOperand(DstIndex, SrcOp);
1178  Flags[ID].first = SrcOp;
1179  };
1180 
1181  // If either flag has override behavior, handle it first.
1182  if (DstBehaviorValue == Module::Override) {
1183  // Diagnose inconsistent flags which both have override behavior.
1184  if (SrcBehaviorValue == Module::Override &&
1185  SrcOp->getOperand(2) != DstOp->getOperand(2))
1186  return stringErr("linking module flags '" + ID->getString() +
1187  "': IDs have conflicting override values");
1188  continue;
1189  } else if (SrcBehaviorValue == Module::Override) {
1190  // Update the destination flag to that of the source.
1191  overrideDstValue();
1192  continue;
1193  }
1194 
1195  // Diagnose inconsistent merge behavior types.
1196  if (SrcBehaviorValue != DstBehaviorValue)
1197  return stringErr("linking module flags '" + ID->getString() +
1198  "': IDs have conflicting behaviors");
1199 
1200  auto replaceDstValue = [&](MDNode *New) {
1201  Metadata *FlagOps[] = {DstOp->getOperand(0), ID, New};
1202  MDNode *Flag = MDNode::get(DstM.getContext(), FlagOps);
1203  DstModFlags->setOperand(DstIndex, Flag);
1204  Flags[ID].first = Flag;
1205  };
1206 
1207  // Perform the merge for standard behavior types.
1208  switch (SrcBehaviorValue) {
1209  case Module::Require:
1210  case Module::Override:
1211  llvm_unreachable("not possible");
1212  case Module::Error: {
1213  // Emit an error if the values differ.
1214  if (SrcOp->getOperand(2) != DstOp->getOperand(2))
1215  return stringErr("linking module flags '" + ID->getString() +
1216  "': IDs have conflicting values");
1217  continue;
1218  }
1219  case Module::Warning: {
1220  // Emit a warning if the values differ.
1221  if (SrcOp->getOperand(2) != DstOp->getOperand(2)) {
1222  emitWarning("linking module flags '" + ID->getString() +
1223  "': IDs have conflicting values");
1224  }
1225  continue;
1226  }
1227  case Module::Max: {
1228  ConstantInt *DstValue =
1229  mdconst::extract<ConstantInt>(DstOp->getOperand(2));
1230  ConstantInt *SrcValue =
1231  mdconst::extract<ConstantInt>(SrcOp->getOperand(2));
1232  if (SrcValue->getZExtValue() > DstValue->getZExtValue())
1233  overrideDstValue();
1234  break;
1235  }
1236  case Module::Append: {
1237  MDNode *DstValue = cast<MDNode>(DstOp->getOperand(2));
1238  MDNode *SrcValue = cast<MDNode>(SrcOp->getOperand(2));
1240  MDs.reserve(DstValue->getNumOperands() + SrcValue->getNumOperands());
1241  MDs.append(DstValue->op_begin(), DstValue->op_end());
1242  MDs.append(SrcValue->op_begin(), SrcValue->op_end());
1243 
1244  replaceDstValue(MDNode::get(DstM.getContext(), MDs));
1245  break;
1246  }
1247  case Module::AppendUnique: {
1249  MDNode *DstValue = cast<MDNode>(DstOp->getOperand(2));
1250  MDNode *SrcValue = cast<MDNode>(SrcOp->getOperand(2));
1251  Elts.insert(DstValue->op_begin(), DstValue->op_end());
1252  Elts.insert(SrcValue->op_begin(), SrcValue->op_end());
1253 
1254  replaceDstValue(MDNode::get(DstM.getContext(),
1255  makeArrayRef(Elts.begin(), Elts.end())));
1256  break;
1257  }
1258  }
1259  }
1260 
1261  // Check all of the requirements.
1262  for (unsigned I = 0, E = Requirements.size(); I != E; ++I) {
1263  MDNode *Requirement = Requirements[I];
1264  MDString *Flag = cast<MDString>(Requirement->getOperand(0));
1265  Metadata *ReqValue = Requirement->getOperand(1);
1266 
1267  MDNode *Op = Flags[Flag].first;
1268  if (!Op || Op->getOperand(2) != ReqValue)
1269  return stringErr("linking module flags '" + Flag->getString() +
1270  "': does not have the required value");
1271  }
1272  return Error::success();
1273 }
1274 
1275 /// Return InlineAsm adjusted with target-specific directives if required.
1276 /// For ARM and Thumb, we have to add directives to select the appropriate ISA
1277 /// to support mixing module-level inline assembly from ARM and Thumb modules.
1278 static std::string adjustInlineAsm(const std::string &InlineAsm,
1279  const Triple &Triple) {
1280  if (Triple.getArch() == Triple::thumb || Triple.getArch() == Triple::thumbeb)
1281  return ".text\n.balign 2\n.thumb\n" + InlineAsm;
1282  if (Triple.getArch() == Triple::arm || Triple.getArch() == Triple::armeb)
1283  return ".text\n.balign 4\n.arm\n" + InlineAsm;
1284  return InlineAsm;
1285 }
1286 
1287 Error IRLinker::run() {
1288  // Ensure metadata materialized before value mapping.
1289  if (SrcM->getMaterializer())
1290  if (Error Err = SrcM->getMaterializer()->materializeMetadata())
1291  return Err;
1292 
1293  // Inherit the target data from the source module if the destination module
1294  // doesn't have one already.
1295  if (DstM.getDataLayout().isDefault())
1296  DstM.setDataLayout(SrcM->getDataLayout());
1297 
1298  if (SrcM->getDataLayout() != DstM.getDataLayout()) {
1299  emitWarning("Linking two modules of different data layouts: '" +
1300  SrcM->getModuleIdentifier() + "' is '" +
1301  SrcM->getDataLayoutStr() + "' whereas '" +
1302  DstM.getModuleIdentifier() + "' is '" +
1303  DstM.getDataLayoutStr() + "'\n");
1304  }
1305 
1306  // Copy the target triple from the source to dest if the dest's is empty.
1307  if (DstM.getTargetTriple().empty() && !SrcM->getTargetTriple().empty())
1308  DstM.setTargetTriple(SrcM->getTargetTriple());
1309 
1310  Triple SrcTriple(SrcM->getTargetTriple()), DstTriple(DstM.getTargetTriple());
1311 
1312  if (!SrcM->getTargetTriple().empty()&&
1313  !SrcTriple.isCompatibleWith(DstTriple))
1314  emitWarning("Linking two modules of different target triples: " +
1315  SrcM->getModuleIdentifier() + "' is '" +
1316  SrcM->getTargetTriple() + "' whereas '" +
1317  DstM.getModuleIdentifier() + "' is '" + DstM.getTargetTriple() +
1318  "'\n");
1319 
1320  DstM.setTargetTriple(SrcTriple.merge(DstTriple));
1321 
1322  // Append the module inline asm string.
1323  if (!IsPerformingImport && !SrcM->getModuleInlineAsm().empty()) {
1324  std::string SrcModuleInlineAsm = adjustInlineAsm(SrcM->getModuleInlineAsm(),
1325  SrcTriple);
1326  if (DstM.getModuleInlineAsm().empty())
1327  DstM.setModuleInlineAsm(SrcModuleInlineAsm);
1328  else
1329  DstM.setModuleInlineAsm(DstM.getModuleInlineAsm() + "\n" +
1330  SrcModuleInlineAsm);
1331  }
1332 
1333  // Loop over all of the linked values to compute type mappings.
1334  computeTypeMapping();
1335 
1336  std::reverse(Worklist.begin(), Worklist.end());
1337  while (!Worklist.empty()) {
1338  GlobalValue *GV = Worklist.back();
1339  Worklist.pop_back();
1340 
1341  // Already mapped.
1342  if (ValueMap.find(GV) != ValueMap.end() ||
1343  AliasValueMap.find(GV) != AliasValueMap.end())
1344  continue;
1345 
1346  assert(!GV->isDeclaration());
1347  Mapper.mapValue(*GV);
1348  if (FoundError)
1349  return std::move(*FoundError);
1350  }
1351 
1352  // Note that we are done linking global value bodies. This prevents
1353  // metadata linking from creating new references.
1354  DoneLinkingBodies = true;
1355  Mapper.addFlags(RF_NullMapMissingGlobalValues);
1356 
1357  // Remap all of the named MDNodes in Src into the DstM module. We do this
1358  // after linking GlobalValues so that MDNodes that reference GlobalValues
1359  // are properly remapped.
1360  linkNamedMDNodes();
1361 
1362  // Merge the module flags into the DstM module.
1363  return linkModuleFlagsMetadata();
1364 }
1365 
1367  : ETypes(E), IsPacked(P) {}
1368 
1370  : ETypes(ST->elements()), IsPacked(ST->isPacked()) {}
1371 
1373  return IsPacked == That.IsPacked && ETypes == That.ETypes;
1374 }
1375 
1377  return !this->operator==(That);
1378 }
1379 
1380 StructType *IRMover::StructTypeKeyInfo::getEmptyKey() {
1382 }
1383 
1384 StructType *IRMover::StructTypeKeyInfo::getTombstoneKey() {
1386 }
1387 
1388 unsigned IRMover::StructTypeKeyInfo::getHashValue(const KeyTy &Key) {
1389  return hash_combine(hash_combine_range(Key.ETypes.begin(), Key.ETypes.end()),
1390  Key.IsPacked);
1391 }
1392 
1393 unsigned IRMover::StructTypeKeyInfo::getHashValue(const StructType *ST) {
1394  return getHashValue(KeyTy(ST));
1395 }
1396 
1398  const StructType *RHS) {
1399  if (RHS == getEmptyKey() || RHS == getTombstoneKey())
1400  return false;
1401  return LHS == KeyTy(RHS);
1402 }
1403 
1405  const StructType *RHS) {
1406  if (RHS == getEmptyKey() || RHS == getTombstoneKey())
1407  return LHS == RHS;
1408  return KeyTy(LHS) == KeyTy(RHS);
1409 }
1410 
1412  assert(!Ty->isOpaque());
1413  NonOpaqueStructTypes.insert(Ty);
1414 }
1415 
1417  assert(!Ty->isOpaque());
1418  NonOpaqueStructTypes.insert(Ty);
1419  bool Removed = OpaqueStructTypes.erase(Ty);
1420  (void)Removed;
1421  assert(Removed);
1422 }
1423 
1425  assert(Ty->isOpaque());
1426  OpaqueStructTypes.insert(Ty);
1427 }
1428 
1429 StructType *
1431  bool IsPacked) {
1432  IRMover::StructTypeKeyInfo::KeyTy Key(ETypes, IsPacked);
1433  auto I = NonOpaqueStructTypes.find_as(Key);
1434  return I == NonOpaqueStructTypes.end() ? nullptr : *I;
1435 }
1436 
1438  if (Ty->isOpaque())
1439  return OpaqueStructTypes.count(Ty);
1440  auto I = NonOpaqueStructTypes.find(Ty);
1441  return I == NonOpaqueStructTypes.end() ? false : *I == Ty;
1442 }
1443 
1444 IRMover::IRMover(Module &M) : Composite(M) {
1445  TypeFinder StructTypes;
1446  StructTypes.run(M, /* OnlyNamed */ false);
1447  for (StructType *Ty : StructTypes) {
1448  if (Ty->isOpaque())
1449  IdentifiedStructTypes.addOpaque(Ty);
1450  else
1451  IdentifiedStructTypes.addNonOpaque(Ty);
1452  }
1453  // Self-map metadatas in the destination module. This is needed when
1454  // DebugTypeODRUniquing is enabled on the LLVMContext, since metadata in the
1455  // destination module may be reached from the source module.
1456  for (auto *MD : StructTypes.getVisitedMetadata()) {
1457  SharedMDs[MD].reset(const_cast<MDNode *>(MD));
1458  }
1459 }
1460 
1462  std::unique_ptr<Module> Src, ArrayRef<GlobalValue *> ValuesToLink,
1463  std::function<void(GlobalValue &, ValueAdder Add)> AddLazyFor,
1464  bool IsPerformingImport) {
1465  IRLinker TheIRLinker(Composite, SharedMDs, IdentifiedStructTypes,
1466  std::move(Src), ValuesToLink, std::move(AddLazyFor),
1467  IsPerformingImport);
1468  Error E = TheIRLinker.run();
1469  Composite.dropTriviallyDeadConstantArrays();
1470  return E;
1471 }
bool isDeclarationForLinker() const
Definition: GlobalValue.h:523
uint64_t CallInst * C
StringRef getSection() const
Get the custom section of this global if it has one.
Definition: GlobalObject.h:90
unsigned getAlignment() const
Definition: GlobalObject.h:59
ThreadLocalMode getThreadLocalMode() const
Definition: GlobalValue.h:254
static MDTuple * get(LLVMContext &Context, ArrayRef< Metadata *> MDs)
Definition: Metadata.h:1131
bool hasLocalLinkage() const
Definition: GlobalValue.h:435
Takes the max of the two values, which are required to be integers.
Definition: Module.h:143
MDNode * getOperand(unsigned i) const
Definition: Metadata.cpp:1081
const Constant * getInitializer() const
getInitializer - Return the initializer for this global variable.
Compute iterated dominance frontiers using a linear time algorithm.
Definition: AllocatorList.h:24
size_type size() const
Determine the number of elements in the SetVector.
Definition: SetVector.h:78
KeyTy(ArrayRef< Type *> E, bool P)
Definition: IRMover.cpp:1366
A Module instance is used to store all the information related to an LLVM module. ...
Definition: Module.h:63
LLVM_ATTRIBUTE_ALWAYS_INLINE size_type size() const
Definition: SmallVector.h:136
iterator end()
Definition: Function.h:639
LLVM_NODISCARD size_t rfind(char C, size_t From=npos) const
Search for the last character C in the string.
Definition: StringRef.h:360
Implements a dense probed hash-table based set.
Definition: DenseSet.h:221
Any global values not in value map are mapped to null instead of mapping to self. ...
Definition: ValueMapper.h:99
void addOperand(MDNode *M)
Definition: Metadata.cpp:1087
static PointerType * get(Type *ElementType, unsigned AddressSpace)
This constructs a pointer to an object of the specified type in a numbered address space...
Definition: Type.cpp:617
Externally visible function.
Definition: GlobalValue.h:49
LLVMContext & getContext() const
All values hold a context through their type.
Definition: Value.cpp:738
bool hasPrologueData() const
Check whether this function has prologue data.
Definition: Function.h:701
13: Structures
Definition: Type.h:73
Metadata node.
Definition: Metadata.h:862
F(f)
Context for (re-)mapping values (and metadata).
Definition: ValueMapper.h:142
const MDOperand & getOperand(unsigned I) const
Definition: Metadata.h:1067
unsigned getPointerAddressSpace() const
Get the address space of this pointer or pointer vector type.
Definition: DerivedTypes.h:503
void switchToNonOpaque(StructType *Ty)
Definition: IRMover.cpp:1416
bool isOpaque() const
Return true if this is a type with an identity that has no body specified yet.
Definition: DerivedTypes.h:269
bool hasExternalWeakLinkage() const
Definition: GlobalValue.h:436
Error takeError()
Take ownership of the stored error.
Definition: Error.h:537
15: Pointers
Definition: Type.h:75
void reserve(size_type N)
Definition: SmallVector.h:378
void setAlignment(unsigned Align)
Definition: Globals.cpp:111
void setOperand(unsigned I, MDNode *New)
Definition: Metadata.cpp:1089
12: Functions
Definition: Type.h:72
iterator end()
Get an iterator to the end of the SetVector.
Definition: SetVector.h:93
op_iterator op_end() const
Definition: Metadata.h:1061
Constant * getPrologueData() const
Get the prologue data associated with this function.
Definition: Function.cpp:1293
LLVMContext & getContext() const
Return the LLVMContext in which this type was uniqued.
Definition: Type.h:130
Adds a requirement that another module flag be present and have a specified value after linking is pe...
Definition: Module.h:127
Appends the two values, which are required to be metadata nodes.
Definition: Module.h:135
void copyMetadata(const GlobalObject *Src, unsigned Offset)
Copy metadata from Src, adjusting offsets by Offset.
Definition: Metadata.cpp:1451
A tuple of MDNodes.
Definition: Metadata.h:1323
bool hasPrefixData() const
Check whether this function has prefix data.
Definition: Function.h:692
DiagnosticSeverity
Defines the different supported severity of a diagnostic.
static ManagedStatic< DebugCounter > DC
Twine - A lightweight data structure for efficiently representing the concatenation of temporary valu...
Definition: Twine.h:81
ArrayRef< T > makeArrayRef(const T &OneElt)
Construct an ArrayRef from a single element.
Definition: ArrayRef.h:451
TypeID getTypeID() const
Return the type id for the type.
Definition: Type.h:138
void copyAttributesFrom(const GlobalValue *Src)
Definition: GlobalAlias.h:62
Class to represent struct types.
Definition: DerivedTypes.h:201
bool isConstant() const
If the value is a global constant, its value is immutable throughout the runtime execution of the pro...
This class consists of common code factored out of the SmallVector class to reduce code duplication b...
Definition: APFloat.h:42
unsigned getNumOperands() const
Definition: Metadata.cpp:1077
void setName(const Twine &Name)
Change the name of the value.
Definition: Value.cpp:295
Tagged union holding either a T or a Error.
Definition: CachePruning.h:23
Interface for custom diagnostic printing.
uint64_t getNumElements() const
Definition: DerivedTypes.h:359
static StructType * get(LLVMContext &Context, ArrayRef< Type *> Elements, bool isPacked=false)
This static method is the primary way to create a literal StructType.
Definition: Type.cpp:336
Constant * getPrefixData() const
Get the prefix data associated with this function.
Definition: Function.cpp:1283
op_iterator op_begin() const
Definition: Metadata.h:1057
auto reverse(ContainerTy &&C, typename std::enable_if< has_rbegin< ContainerTy >::value >::type *=nullptr) -> decltype(make_range(C.rbegin(), C.rend()))
Definition: STLExtras.h:237
Key
PAL metadata keys.
llvm::Optional< Function * > remangleIntrinsicFunction(Function *F)
Definition: Function.cpp:1190
Class to represent function types.
Definition: DerivedTypes.h:103
Instruct the remapper to move distinct metadata instead of duplicating it when there are module-level...
Definition: ValueMapper.h:95
Type * getType() const
All values are typed, get the type of this value.
Definition: Value.h:245
bool insert(const value_type &X)
Insert a new element into the SetVector.
Definition: SetVector.h:142
static bool isEqual(const Function &Caller, const Function &Callee)
Error move(std::unique_ptr< Module > Src, ArrayRef< GlobalValue *> ValuesToLink, std::function< void(GlobalValue &GV, ValueAdder Add)> AddLazyFor, bool IsPerformingImport)
Move in the provide values in ValuesToLink from Src.
Definition: IRMover.cpp:1461
ArchType getArch() const
getArch - Get the parsed architecture type of this triple.
Definition: Triple.h:283
#define T
Class to represent array types.
Definition: DerivedTypes.h:369
iterator find(const KeyT &Val)
Definition: ValueMap.h:162
iterator begin()
Get an iterator to the beginning of the SetVector.
Definition: SetVector.h:83
bool operator!=(const KeyTy &that) const
Definition: IRMover.cpp:1376
GlobalValue * getNamedValue(StringRef Name) const
Return the global value in the module with the specified name, of arbitrary type. ...
Definition: Module.cpp:112
ArrayRef - Represent a constant reference to an array (0 or more elements consecutively in memory)...
Definition: APInt.h:33
SmallString - A SmallString is just a SmallVector with methods and accessors that make it work better...
Definition: SmallString.h:26
bool hasPersonalityFn() const
Check whether this function has a personality function.
Definition: Function.h:683
LinkageTypes getLinkage() const
Definition: GlobalValue.h:450
void replaceAllUsesWith(Value *V)
Change all uses of this to point to a new Value.
Definition: Value.cpp:439
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: ValueMap.h:171
LLVM_NODISCARD LLVM_ATTRIBUTE_ALWAYS_INLINE StringRef substr(size_t Start, size_t N=npos) const
Return a reference to the substring from [Start, Start + N).
Definition: StringRef.h:598
void setBody(ArrayRef< Type *> Elements, bool isPacked=false)
Specify a body for an opaque identified type.
Definition: Type.cpp:356
void takeName(Value *V)
Transfer the name from V to this value.
Definition: Value.cpp:301
Class to represent pointers.
Definition: DerivedTypes.h:467
Flag
These should be considered private to the implementation of the MCInstrDesc class.
Definition: MCInstrDesc.h:121
Constant * getAggregateElement(unsigned Elt) const
For aggregates (struct/array/vector) return the constant that corresponds to the specified element if...
Definition: Constants.cpp:328
bool hasAppendingLinkage() const
Definition: GlobalValue.h:432
StringRef getString() const
Definition: Metadata.cpp:464
static Constant * getBitCast(Constant *C, Type *Ty, bool OnlyIfReduced=false)
Definition: Constants.cpp:1740
ExternalWeak linkage description.
Definition: GlobalValue.h:58
static MDTuple * get(LLVMContext &Context, ArrayRef< Metadata *> MDs)
Definition: Metadata.h:1164
#define P(N)
This is a class that can be implemented by clients to materialize Values on demand.
Definition: ValueMapper.h:51
This is the base abstract class for diagnostic reporting in the backend.
void stealArgumentListFrom(Function &Src)
Steal arguments from another function.
Definition: Function.cpp:279
Emits an error if two values disagree, otherwise the resulting value is that of the operands...
Definition: Module.h:114
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:149
VisibilityTypes getVisibility() const
Definition: GlobalValue.h:232
bool hasName() const
Definition: Value.h:251
The instances of the Type class are immutable: once they are created, they are never changed...
Definition: Type.h:46
static GCRegistry::Add< CoreCLRGC > E("coreclr", "CoreCLR-compatible GC")
This is an important base class in LLVM.
Definition: Constant.h:42
LLVM_ATTRIBUTE_ALWAYS_INLINE iterator begin()
Definition: SmallVector.h:116
unsigned getNumContainedTypes() const
Return the number of types in the derived type.
Definition: Type.h:336
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:371
void eraseFromParent()
eraseFromParent - This method unlinks &#39;this&#39; from the containing module and deletes it...
Definition: Globals.cpp:354
Optional< MDMapT > & getMDMap()
Definition: ValueMap.h:122
void splice(iterator where, iplist_impl &L2)
Definition: ilist.h:342
StringRef getName() const
Return the name for this struct type if it has an identity.
Definition: Type.cpp:487
static FunctionType * get(Type *Result, ArrayRef< Type *> Params, bool isVarArg)
This static method is the primary way of constructing a FunctionType.
Definition: Type.cpp:297
unsigned getAddressSpace() const
Return the address space of the Pointer type.
Definition: DerivedTypes.h:495
auto remove_if(R &&Range, UnaryPredicate P) -> decltype(adl_begin(Range))
Provide wrappers to std::remove_if which take ranges instead of having to pass begin/end explicitly...
Definition: STLExtras.h:886
Error materialize()
Make sure this GlobalValue is fully read.
Definition: Globals.cpp:50
const Constant * stripPointerCasts() const
Definition: Constant.h:169
iterator erase(const_iterator CI)
Definition: SmallVector.h:447
LLVM_NODISCARD char back() const
back - Get the last character in the string.
Definition: StringRef.h:149
#define llvm_unreachable(msg)
Marks that the current location is not supposed to be reachable.
Triple - Helper class for working with autoconf configuration names.
Definition: Triple.h:44
Base class for scope-like contexts.
static void getArrayElements(const Constant *C, SmallVectorImpl< Constant *> &Dest)
Definition: IRMover.cpp:774
iterator end()
Definition: ValueMap.h:142
14: Arrays
Definition: Type.h:74
A SetVector that performs no allocations if smaller than a certain size.
Definition: SetVector.h:298
static ErrorSuccess success()
Create a success value.
Definition: Error.h:313
SmallPtrSet - This class implements a set which is optimized for holding SmallSize or less elements...
Definition: SmallPtrSet.h:418
This is the shared class of boolean and integer constants.
Definition: Constants.h:84
void setSelectionKind(SelectionKind Val)
Definition: Comdat.h:46
16: SIMD &#39;packed&#39; format, or other vector type
Definition: Type.h:76
void dropTriviallyDeadConstantArrays()
Destroy ConstantArrays in LLVMContext if they are not used.
void run(const Module &M, bool onlyNamed)
Definition: TypeFinder.cpp:32
This is a &#39;vector&#39; (really, a variable-sized array), optimized for the case when the array is small...
Definition: SmallVector.h:862
CHAIN = SC CHAIN, Imm128 - System call.
bool hasGlobalUnnamedAddr() const
Definition: GlobalValue.h:199
void print(DiagnosticPrinter &DP) const override
Print using the given DP a user-friendly message.
Definition: IRMover.cpp:342
bool operator==(const KeyTy &that) const
Definition: IRMover.cpp:1372
void setLinkage(LinkageTypes LT)
Definition: GlobalValue.h:444
Uses the specified value, regardless of the behavior or value of the other module.
Definition: Module.h:132
FunctionType * getFunctionType() const
Returns the FunctionType for me.
Definition: Function.h:145
bool isLiteral() const
Return true if this type is uniqued by structural equivalence, false if it is a struct definition...
Definition: DerivedTypes.h:265
static StringRef getTypeNamePrefix(StringRef Name)
Definition: IRMover.cpp:685
const Comdat * getComdat() const
Definition: Globals.cpp:166
hash_code hash_combine(const Ts &...args)
Combine values into a single hash_code.
Definition: Hashing.h:602
LinkDiagnosticInfo(DiagnosticSeverity Severity, const Twine &Msg)
Definition: IRMover.cpp:339
Emits a warning if two values disagree.
Definition: Module.h:118
hash_code hash_combine_range(InputIteratorT first, InputIteratorT last)
Compute a hash_code for a sequence of values.
Definition: Hashing.h:480
This is a class that can be implemented by clients to remap types when cloning constants and instruct...
Definition: ValueMapper.h:38
If this flag is set, the remapper ignores missing function-local entries (Argument, Instruction, BasicBlock) that are not in the value map.
Definition: ValueMapper.h:91
void setName(StringRef Name)
Change the name of this type to the specified name, or to a name with a suffix if there is a collisio...
Definition: Type.cpp:373
IRMover(Module &M)
Definition: IRMover.cpp:1444
void eraseFromParent()
This method unlinks &#39;this&#39; from the containing module and deletes it.
Definition: Globals.cpp:85
LLVM_ATTRIBUTE_ALWAYS_INLINE iterator end()
Definition: SmallVector.h:120
bool isPacked() const
Definition: DerivedTypes.h:261
bool isFunctionTy() const
True if this is an instance of FunctionType.
Definition: Type.h:212
static const size_t npos
Definition: StringRef.h:51
Appends the two values, which are required to be metadata nodes.
Definition: Module.h:140
void emplace_back(ArgTypes &&... Args)
Definition: SmallVector.h:654
LLVM_NODISCARD bool empty() const
Definition: SmallVector.h:61
StringRef getName() const
Return a constant reference to the value&#39;s name.
Definition: Value.cpp:224
void copyAttributesFrom(const GlobalVariable *Src)
copyAttributesFrom - copy all additional attributes (those not needed to create a GlobalVariable) fro...
Definition: Globals.cpp:381
#define I(x, y, z)
Definition: MD5.cpp:58
void setPrologueData(Constant *PrologueData)
Definition: Function.cpp:1298
static ArrayType * get(Type *ElementType, uint64_t NumElements)
This static method is the primary way to construct an ArrayType.
Definition: Type.cpp:568
LLVM_NODISCARD 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:323
Type * getValueType() const
Definition: GlobalValue.h:275
const BasicBlockListType & getBasicBlockList() const
Get the underlying elements of the Function...
Definition: Function.h:614
Rename collisions when linking (static functions).
Definition: GlobalValue.h:56
ValueT lookup(const_arg_type_t< KeyT > Val) const
lookup - Return the entry for the specified key, or a default constructed value if no such entry exis...
Definition: DenseMap.h:181
bool isDeclaration() const
Return true if the primary definition of this global value is outside of the current translation unit...
Definition: Globals.cpp:201
assert(ImpDefSCC.getReg()==AMDGPU::SCC &&ImpDefSCC.isDef())
std::function< void(GlobalValue &)> ValueAdder
Definition: IRMover.h:65
StructType * findNonOpaque(ArrayRef< Type *> ETypes, bool IsPacked)
Definition: IRMover.cpp:1430
Module * getParent()
Get the module that this global value is contained inside of...
Definition: GlobalValue.h:565
LLVM Value Representation.
Definition: Value.h:73
Constant * getPersonalityFn() const
Get the personality function associated with this function.
Definition: Function.cpp:1273
static VectorType * get(Type *ElementType, unsigned NumElements)
This static method is the primary way to construct an VectorType.
Definition: Type.cpp:593
static StructType * create(LLVMContext &Context, StringRef Name)
This creates an identified struct.
Definition: Type.cpp:424
Lightweight error class with error context and mandatory checking.
Definition: Error.h:156
static std::string adjustInlineAsm(const std::string &InlineAsm, const Triple &Triple)
Return InlineAsm adjusted with target-specific directives if required.
Definition: IRMover.cpp:1278
static void forceRenaming(GlobalValue *GV, StringRef Name)
The LLVM SymbolTable class autorenames globals that conflict in the symbol table. ...
Definition: IRMover.cpp:525
Type * getElementType() const
Definition: DerivedTypes.h:360
print Print MemDeps of function
StringRef - Represent a constant reference to a string, i.e.
Definition: StringRef.h:49
A single uniqued string.
Definition: Metadata.h:602
static Function * Create(FunctionType *Ty, LinkageTypes Linkage, const Twine &N="", Module *M=nullptr)
Definition: Function.h:136
void setPersonalityFn(Constant *Fn)
Definition: Function.cpp:1278
unsigned getNumOperands() const
Return number of MDNode operands.
Definition: Metadata.h:1073
bool hasName() const
Return true if this is a named struct that has a non-empty name.
Definition: DerivedTypes.h:275
MDMapT & MD()
Definition: ValueMap.h:117
TypeFinder - Walk over a module, identifying all of the types that are used by the module...
Definition: TypeFinder.h:31
Root of the metadata hierarchy.
Definition: Metadata.h:58
Function Alias Analysis false
static IntegerType * getInt8Ty(LLVMContext &C)
Definition: Type.cpp:174
static GlobalAlias * create(Type *Ty, unsigned AddressSpace, LinkageTypes Linkage, const Twine &Name, Constant *Aliasee, Module *Parent)
If a parent module is specified, the alias is automatically inserted into the end of the specified mo...
Definition: Globals.cpp:418
PointerType * getType() const
Global values are always pointers.
Definition: GlobalValue.h:273
Type * getContainedType(unsigned i) const
This method is used to implement the type iterator (defined at the end of the file).
Definition: Type.h:330
std::error_code inconvertibleErrorCode()
The value returned by this function can be returned from convertToErrorCode for Error values where no...
Definition: Error.cpp:73
void setPrefixData(Constant *PrefixData)
Definition: Function.cpp:1288
void resize(size_type N)
Definition: SmallVector.h:353
const Constant * getAliasee() const
Definition: GlobalAlias.h:78