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  if (!IsUniqued) {
245  StructType *STy = cast<StructType>(Ty);
246  // This is actually a type from the destination module, this can be reached
247  // when this type is loaded in another module, added to DstStructTypesSet,
248  // and then we reach the same type in another module where it has not been
249  // added to MappedTypes. (PR37684)
250  if (STy->getContext().isODRUniquingDebugTypes() && !STy->isOpaque() &&
251  DstStructTypesSet.hasType(STy))
252  return *Entry = STy;
253 
254 #ifndef NDEBUG
255  for (auto &Pair : MappedTypes) {
256  assert(!(Pair.first != Ty && Pair.second == Ty) &&
257  "mapping to a source type");
258  }
259 #endif
260 
261  if (!Visited.insert(STy).second) {
263  return *Entry = DTy;
264  }
265  }
266 
267  // If this is not a recursive type, then just map all of the elements and
268  // then rebuild the type from inside out.
269  SmallVector<Type *, 4> ElementTypes;
270 
271  // If there are no element types to map, then the type is itself. This is
272  // true for the anonymous {} struct, things like 'float', integers, etc.
273  if (Ty->getNumContainedTypes() == 0 && IsUniqued)
274  return *Entry = Ty;
275 
276  // Remap all of the elements, keeping track of whether any of them change.
277  bool AnyChange = false;
278  ElementTypes.resize(Ty->getNumContainedTypes());
279  for (unsigned I = 0, E = Ty->getNumContainedTypes(); I != E; ++I) {
280  ElementTypes[I] = get(Ty->getContainedType(I), Visited);
281  AnyChange |= ElementTypes[I] != Ty->getContainedType(I);
282  }
283 
284  // If we found our type while recursively processing stuff, just use it.
285  Entry = &MappedTypes[Ty];
286  if (*Entry) {
287  if (auto *DTy = dyn_cast<StructType>(*Entry)) {
288  if (DTy->isOpaque()) {
289  auto *STy = cast<StructType>(Ty);
290  finishType(DTy, STy, ElementTypes);
291  }
292  }
293  return *Entry;
294  }
295 
296  // If all of the element types mapped directly over and the type is not
297  // a named struct, then the type is usable as-is.
298  if (!AnyChange && IsUniqued)
299  return *Entry = Ty;
300 
301  // Otherwise, rebuild a modified type.
302  switch (Ty->getTypeID()) {
303  default:
304  llvm_unreachable("unknown derived type to remap");
305  case Type::ArrayTyID:
306  return *Entry = ArrayType::get(ElementTypes[0],
307  cast<ArrayType>(Ty)->getNumElements());
308  case Type::VectorTyID:
309  return *Entry = VectorType::get(ElementTypes[0],
310  cast<VectorType>(Ty)->getNumElements());
311  case Type::PointerTyID:
312  return *Entry = PointerType::get(ElementTypes[0],
313  cast<PointerType>(Ty)->getAddressSpace());
314  case Type::FunctionTyID:
315  return *Entry = FunctionType::get(ElementTypes[0],
316  makeArrayRef(ElementTypes).slice(1),
317  cast<FunctionType>(Ty)->isVarArg());
318  case Type::StructTyID: {
319  auto *STy = cast<StructType>(Ty);
320  bool IsPacked = STy->isPacked();
321  if (IsUniqued)
322  return *Entry = StructType::get(Ty->getContext(), ElementTypes, IsPacked);
323 
324  // If the type is opaque, we can just use it directly.
325  if (STy->isOpaque()) {
326  DstStructTypesSet.addOpaque(STy);
327  return *Entry = Ty;
328  }
329 
330  if (StructType *OldT =
331  DstStructTypesSet.findNonOpaque(ElementTypes, IsPacked)) {
332  STy->setName("");
333  return *Entry = OldT;
334  }
335 
336  if (!AnyChange) {
337  DstStructTypesSet.addNonOpaque(STy);
338  return *Entry = Ty;
339  }
340 
342  finishType(DTy, STy, ElementTypes);
343  return *Entry = DTy;
344  }
345  }
346 }
347 
349  const Twine &Msg)
350  : DiagnosticInfo(DK_Linker, Severity), Msg(Msg) {}
351 void LinkDiagnosticInfo::print(DiagnosticPrinter &DP) const { DP << Msg; }
352 
353 //===----------------------------------------------------------------------===//
354 // IRLinker implementation.
355 //===----------------------------------------------------------------------===//
356 
357 namespace {
358 class IRLinker;
359 
360 /// Creates prototypes for functions that are lazily linked on the fly. This
361 /// speeds up linking for modules with many/ lazily linked functions of which
362 /// few get used.
363 class GlobalValueMaterializer final : public ValueMaterializer {
364  IRLinker &TheIRLinker;
365 
366 public:
367  GlobalValueMaterializer(IRLinker &TheIRLinker) : TheIRLinker(TheIRLinker) {}
368  Value *materialize(Value *V) override;
369 };
370 
371 class LocalValueMaterializer final : public ValueMaterializer {
372  IRLinker &TheIRLinker;
373 
374 public:
375  LocalValueMaterializer(IRLinker &TheIRLinker) : TheIRLinker(TheIRLinker) {}
376  Value *materialize(Value *V) override;
377 };
378 
379 /// Type of the Metadata map in \a ValueToValueMapTy.
381 
382 /// This is responsible for keeping track of the state used for moving data
383 /// from SrcM to DstM.
384 class IRLinker {
385  Module &DstM;
386  std::unique_ptr<Module> SrcM;
387 
388  /// See IRMover::move().
389  std::function<void(GlobalValue &, IRMover::ValueAdder)> AddLazyFor;
390 
391  TypeMapTy TypeMap;
392  GlobalValueMaterializer GValMaterializer;
393  LocalValueMaterializer LValMaterializer;
394 
395  /// A metadata map that's shared between IRLinker instances.
396  MDMapT &SharedMDs;
397 
398  /// Mapping of values from what they used to be in Src, to what they are now
399  /// in DstM. ValueToValueMapTy is a ValueMap, which involves some overhead
400  /// due to the use of Value handles which the Linker doesn't actually need,
401  /// but this allows us to reuse the ValueMapper code.
403  ValueToValueMapTy AliasValueMap;
404 
405  DenseSet<GlobalValue *> ValuesToLink;
406  std::vector<GlobalValue *> Worklist;
407 
408  void maybeAdd(GlobalValue *GV) {
409  if (ValuesToLink.insert(GV).second)
410  Worklist.push_back(GV);
411  }
412 
413  /// Whether we are importing globals for ThinLTO, as opposed to linking the
414  /// source module. If this flag is set, it means that we can rely on some
415  /// other object file to define any non-GlobalValue entities defined by the
416  /// source module. This currently causes us to not link retained types in
417  /// debug info metadata and module inline asm.
418  bool IsPerformingImport;
419 
420  /// Set to true when all global value body linking is complete (including
421  /// lazy linking). Used to prevent metadata linking from creating new
422  /// references.
423  bool DoneLinkingBodies = false;
424 
425  /// The Error encountered during materialization. We use an Optional here to
426  /// avoid needing to manage an unconsumed success value.
427  Optional<Error> FoundError;
428  void setError(Error E) {
429  if (E)
430  FoundError = std::move(E);
431  }
432 
433  /// Most of the errors produced by this module are inconvertible StringErrors.
434  /// This convenience function lets us return one of those more easily.
435  Error stringErr(const Twine &T) {
436  return make_error<StringError>(T, inconvertibleErrorCode());
437  }
438 
439  /// Entry point for mapping values and alternate context for mapping aliases.
440  ValueMapper Mapper;
441  unsigned AliasMCID;
442 
443  /// Handles cloning of a global values from the source module into
444  /// the destination module, including setting the attributes and visibility.
445  GlobalValue *copyGlobalValueProto(const GlobalValue *SGV, bool ForDefinition);
446 
447  void emitWarning(const Twine &Message) {
448  SrcM->getContext().diagnose(LinkDiagnosticInfo(DS_Warning, Message));
449  }
450 
451  /// Given a global in the source module, return the global in the
452  /// destination module that is being linked to, if any.
453  GlobalValue *getLinkedToGlobal(const GlobalValue *SrcGV) {
454  // If the source has no name it can't link. If it has local linkage,
455  // there is no name match-up going on.
456  if (!SrcGV->hasName() || SrcGV->hasLocalLinkage())
457  return nullptr;
458 
459  // Otherwise see if we have a match in the destination module's symtab.
460  GlobalValue *DGV = DstM.getNamedValue(SrcGV->getName());
461  if (!DGV)
462  return nullptr;
463 
464  // If we found a global with the same name in the dest module, but it has
465  // internal linkage, we are really not doing any linkage here.
466  if (DGV->hasLocalLinkage())
467  return nullptr;
468 
469  // Otherwise, we do in fact link to the destination global.
470  return DGV;
471  }
472 
473  void computeTypeMapping();
474 
475  Expected<Constant *> linkAppendingVarProto(GlobalVariable *DstGV,
476  const GlobalVariable *SrcGV);
477 
478  /// Given the GlobaValue \p SGV in the source module, and the matching
479  /// GlobalValue \p DGV (if any), return true if the linker will pull \p SGV
480  /// into the destination module.
481  ///
482  /// Note this code may call the client-provided \p AddLazyFor.
483  bool shouldLink(GlobalValue *DGV, GlobalValue &SGV);
484  Expected<Constant *> linkGlobalValueProto(GlobalValue *GV, bool ForAlias);
485 
486  Error linkModuleFlagsMetadata();
487 
488  void linkGlobalVariable(GlobalVariable &Dst, GlobalVariable &Src);
489  Error linkFunctionBody(Function &Dst, Function &Src);
490  void linkAliasBody(GlobalAlias &Dst, GlobalAlias &Src);
491  Error linkGlobalValueBody(GlobalValue &Dst, GlobalValue &Src);
492 
493  /// Functions that take care of cloning a specific global value type
494  /// into the destination module.
495  GlobalVariable *copyGlobalVariableProto(const GlobalVariable *SGVar);
496  Function *copyFunctionProto(const Function *SF);
497  GlobalValue *copyGlobalAliasProto(const GlobalAlias *SGA);
498 
499  /// When importing for ThinLTO, prevent importing of types listed on
500  /// the DICompileUnit that we don't need a copy of in the importing
501  /// module.
502  void prepareCompileUnitsForImport();
503  void linkNamedMDNodes();
504 
505 public:
506  IRLinker(Module &DstM, MDMapT &SharedMDs,
507  IRMover::IdentifiedStructTypeSet &Set, std::unique_ptr<Module> SrcM,
508  ArrayRef<GlobalValue *> ValuesToLink,
509  std::function<void(GlobalValue &, IRMover::ValueAdder)> AddLazyFor,
510  bool IsPerformingImport)
511  : DstM(DstM), SrcM(std::move(SrcM)), AddLazyFor(std::move(AddLazyFor)),
512  TypeMap(Set), GValMaterializer(*this), LValMaterializer(*this),
513  SharedMDs(SharedMDs), IsPerformingImport(IsPerformingImport),
514  Mapper(ValueMap, RF_MoveDistinctMDs | RF_IgnoreMissingLocals, &TypeMap,
515  &GValMaterializer),
516  AliasMCID(Mapper.registerAlternateMappingContext(AliasValueMap,
517  &LValMaterializer)) {
518  ValueMap.getMDMap() = std::move(SharedMDs);
519  for (GlobalValue *GV : ValuesToLink)
520  maybeAdd(GV);
521  if (IsPerformingImport)
522  prepareCompileUnitsForImport();
523  }
524  ~IRLinker() { SharedMDs = std::move(*ValueMap.getMDMap()); }
525 
526  Error run();
527  Value *materialize(Value *V, bool ForAlias);
528 };
529 }
530 
531 /// The LLVM SymbolTable class autorenames globals that conflict in the symbol
532 /// table. This is good for all clients except for us. Go through the trouble
533 /// to force this back.
535  // If the global doesn't force its name or if it already has the right name,
536  // there is nothing for us to do.
537  if (GV->hasLocalLinkage() || GV->getName() == Name)
538  return;
539 
540  Module *M = GV->getParent();
541 
542  // If there is a conflict, rename the conflict.
543  if (GlobalValue *ConflictGV = M->getNamedValue(Name)) {
544  GV->takeName(ConflictGV);
545  ConflictGV->setName(Name); // This will cause ConflictGV to get renamed
546  assert(ConflictGV->getName() != Name && "forceRenaming didn't work");
547  } else {
548  GV->setName(Name); // Force the name back
549  }
550 }
551 
552 Value *GlobalValueMaterializer::materialize(Value *SGV) {
553  return TheIRLinker.materialize(SGV, false);
554 }
555 
556 Value *LocalValueMaterializer::materialize(Value *SGV) {
557  return TheIRLinker.materialize(SGV, true);
558 }
559 
560 Value *IRLinker::materialize(Value *V, bool ForAlias) {
561  auto *SGV = dyn_cast<GlobalValue>(V);
562  if (!SGV)
563  return nullptr;
564 
565  Expected<Constant *> NewProto = linkGlobalValueProto(SGV, ForAlias);
566  if (!NewProto) {
567  setError(NewProto.takeError());
568  return nullptr;
569  }
570  if (!*NewProto)
571  return nullptr;
572 
573  GlobalValue *New = dyn_cast<GlobalValue>(*NewProto);
574  if (!New)
575  return *NewProto;
576 
577  // If we already created the body, just return.
578  if (auto *F = dyn_cast<Function>(New)) {
579  if (!F->isDeclaration())
580  return New;
581  } else if (auto *V = dyn_cast<GlobalVariable>(New)) {
582  if (V->hasInitializer() || V->hasAppendingLinkage())
583  return New;
584  } else {
585  auto *A = cast<GlobalAlias>(New);
586  if (A->getAliasee())
587  return New;
588  }
589 
590  // When linking a global for an alias, it will always be linked. However we
591  // need to check if it was not already scheduled to satisfy a reference from a
592  // regular global value initializer. We know if it has been schedule if the
593  // "New" GlobalValue that is mapped here for the alias is the same as the one
594  // already mapped. If there is an entry in the ValueMap but the value is
595  // different, it means that the value already had a definition in the
596  // destination module (linkonce for instance), but we need a new definition
597  // for the alias ("New" will be different.
598  if (ForAlias && ValueMap.lookup(SGV) == New)
599  return New;
600 
601  if (ForAlias || shouldLink(New, *SGV))
602  setError(linkGlobalValueBody(*New, *SGV));
603 
604  return New;
605 }
606 
607 /// Loop through the global variables in the src module and merge them into the
608 /// dest module.
609 GlobalVariable *IRLinker::copyGlobalVariableProto(const GlobalVariable *SGVar) {
610  // No linking to be performed or linking from the source: simply create an
611  // identical version of the symbol over in the dest module... the
612  // initializer will be filled in later by LinkGlobalInits.
613  GlobalVariable *NewDGV =
614  new GlobalVariable(DstM, TypeMap.get(SGVar->getValueType()),
616  /*init*/ nullptr, SGVar->getName(),
617  /*insertbefore*/ nullptr, SGVar->getThreadLocalMode(),
618  SGVar->getType()->getAddressSpace());
619  NewDGV->setAlignment(SGVar->getAlignment());
620  NewDGV->copyAttributesFrom(SGVar);
621  return NewDGV;
622 }
623 
624 /// Link the function in the source module into the destination module if
625 /// needed, setting up mapping information.
626 Function *IRLinker::copyFunctionProto(const Function *SF) {
627  // If there is no linkage to be performed or we are linking from the source,
628  // bring SF over.
629  auto *F =
630  Function::Create(TypeMap.get(SF->getFunctionType()),
631  GlobalValue::ExternalLinkage, SF->getName(), &DstM);
632  F->copyAttributesFrom(SF);
633  return F;
634 }
635 
636 /// Set up prototypes for any aliases that come over from the source module.
637 GlobalValue *IRLinker::copyGlobalAliasProto(const GlobalAlias *SGA) {
638  // If there is no linkage to be performed or we're linking from the source,
639  // bring over SGA.
640  auto *Ty = TypeMap.get(SGA->getValueType());
641  auto *GA =
643  GlobalValue::ExternalLinkage, SGA->getName(), &DstM);
644  GA->copyAttributesFrom(SGA);
645  return GA;
646 }
647 
648 GlobalValue *IRLinker::copyGlobalValueProto(const GlobalValue *SGV,
649  bool ForDefinition) {
650  GlobalValue *NewGV;
651  if (auto *SGVar = dyn_cast<GlobalVariable>(SGV)) {
652  NewGV = copyGlobalVariableProto(SGVar);
653  } else if (auto *SF = dyn_cast<Function>(SGV)) {
654  NewGV = copyFunctionProto(SF);
655  } else {
656  if (ForDefinition)
657  NewGV = copyGlobalAliasProto(cast<GlobalAlias>(SGV));
658  else if (SGV->getValueType()->isFunctionTy())
659  NewGV =
660  Function::Create(cast<FunctionType>(TypeMap.get(SGV->getValueType())),
661  GlobalValue::ExternalLinkage, SGV->getName(), &DstM);
662  else
663  NewGV = new GlobalVariable(
664  DstM, TypeMap.get(SGV->getValueType()),
665  /*isConstant*/ false, GlobalValue::ExternalLinkage,
666  /*init*/ nullptr, SGV->getName(),
667  /*insertbefore*/ nullptr, SGV->getThreadLocalMode(),
668  SGV->getType()->getAddressSpace());
669  }
670 
671  if (ForDefinition)
672  NewGV->setLinkage(SGV->getLinkage());
673  else if (SGV->hasExternalWeakLinkage())
675 
676  if (auto *NewGO = dyn_cast<GlobalObject>(NewGV)) {
677  // Metadata for global variables and function declarations is copied eagerly.
678  if (isa<GlobalVariable>(SGV) || SGV->isDeclaration())
679  NewGO->copyMetadata(cast<GlobalObject>(SGV), 0);
680  }
681 
682  // Remove these copied constants in case this stays a declaration, since
683  // they point to the source module. If the def is linked the values will
684  // be mapped in during linkFunctionBody.
685  if (auto *NewF = dyn_cast<Function>(NewGV)) {
686  NewF->setPersonalityFn(nullptr);
687  NewF->setPrefixData(nullptr);
688  NewF->setPrologueData(nullptr);
689  }
690 
691  return NewGV;
692 }
693 
695  size_t DotPos = Name.rfind('.');
696  return (DotPos == 0 || DotPos == StringRef::npos || Name.back() == '.' ||
697  !isdigit(static_cast<unsigned char>(Name[DotPos + 1])))
698  ? Name
699  : Name.substr(0, DotPos);
700 }
701 
702 /// Loop over all of the linked values to compute type mappings. For example,
703 /// if we link "extern Foo *x" and "Foo *x = NULL", then we have two struct
704 /// types 'Foo' but one got renamed when the module was loaded into the same
705 /// LLVMContext.
706 void IRLinker::computeTypeMapping() {
707  for (GlobalValue &SGV : SrcM->globals()) {
708  GlobalValue *DGV = getLinkedToGlobal(&SGV);
709  if (!DGV)
710  continue;
711 
712  if (!DGV->hasAppendingLinkage() || !SGV.hasAppendingLinkage()) {
713  TypeMap.addTypeMapping(DGV->getType(), SGV.getType());
714  continue;
715  }
716 
717  // Unify the element type of appending arrays.
718  ArrayType *DAT = cast<ArrayType>(DGV->getValueType());
719  ArrayType *SAT = cast<ArrayType>(SGV.getValueType());
720  TypeMap.addTypeMapping(DAT->getElementType(), SAT->getElementType());
721  }
722 
723  for (GlobalValue &SGV : *SrcM)
724  if (GlobalValue *DGV = getLinkedToGlobal(&SGV))
725  TypeMap.addTypeMapping(DGV->getType(), SGV.getType());
726 
727  for (GlobalValue &SGV : SrcM->aliases())
728  if (GlobalValue *DGV = getLinkedToGlobal(&SGV))
729  TypeMap.addTypeMapping(DGV->getType(), SGV.getType());
730 
731  // Incorporate types by name, scanning all the types in the source module.
732  // At this point, the destination module may have a type "%foo = { i32 }" for
733  // example. When the source module got loaded into the same LLVMContext, if
734  // it had the same type, it would have been renamed to "%foo.42 = { i32 }".
735  std::vector<StructType *> Types = SrcM->getIdentifiedStructTypes();
736  for (StructType *ST : Types) {
737  if (!ST->hasName())
738  continue;
739 
740  if (TypeMap.DstStructTypesSet.hasType(ST)) {
741  // This is actually a type from the destination module.
742  // getIdentifiedStructTypes() can have found it by walking debug info
743  // metadata nodes, some of which get linked by name when ODR Type Uniquing
744  // is enabled on the Context, from the source to the destination module.
745  continue;
746  }
747 
748  auto STTypePrefix = getTypeNamePrefix(ST->getName());
749  if (STTypePrefix.size()== ST->getName().size())
750  continue;
751 
752  // Check to see if the destination module has a struct with the prefix name.
753  StructType *DST = DstM.getTypeByName(STTypePrefix);
754  if (!DST)
755  continue;
756 
757  // Don't use it if this actually came from the source module. They're in
758  // the same LLVMContext after all. Also don't use it unless the type is
759  // actually used in the destination module. This can happen in situations
760  // like this:
761  //
762  // Module A Module B
763  // -------- --------
764  // %Z = type { %A } %B = type { %C.1 }
765  // %A = type { %B.1, [7 x i8] } %C.1 = type { i8* }
766  // %B.1 = type { %C } %A.2 = type { %B.3, [5 x i8] }
767  // %C = type { i8* } %B.3 = type { %C.1 }
768  //
769  // When we link Module B with Module A, the '%B' in Module B is
770  // used. However, that would then use '%C.1'. But when we process '%C.1',
771  // we prefer to take the '%C' version. So we are then left with both
772  // '%C.1' and '%C' being used for the same types. This leads to some
773  // variables using one type and some using the other.
774  if (TypeMap.DstStructTypesSet.hasType(DST))
775  TypeMap.addTypeMapping(DST, ST);
776  }
777 
778  // Now that we have discovered all of the type equivalences, get a body for
779  // any 'opaque' types in the dest module that are now resolved.
780  TypeMap.linkDefinedTypeBodies();
781 }
782 
783 static void getArrayElements(const Constant *C,
785  unsigned NumElements = cast<ArrayType>(C->getType())->getNumElements();
786 
787  for (unsigned i = 0; i != NumElements; ++i)
788  Dest.push_back(C->getAggregateElement(i));
789 }
790 
791 /// If there were any appending global variables, link them together now.
793 IRLinker::linkAppendingVarProto(GlobalVariable *DstGV,
794  const GlobalVariable *SrcGV) {
795  Type *EltTy = cast<ArrayType>(TypeMap.get(SrcGV->getValueType()))
796  ->getElementType();
797 
798  // FIXME: This upgrade is done during linking to support the C API. Once the
799  // old form is deprecated, we should move this upgrade to
800  // llvm::UpgradeGlobalVariable() and simplify the logic here and in
801  // Mapper::mapAppendingVariable() in ValueMapper.cpp.
802  StringRef Name = SrcGV->getName();
803  bool IsNewStructor = false;
804  bool IsOldStructor = false;
805  if (Name == "llvm.global_ctors" || Name == "llvm.global_dtors") {
806  if (cast<StructType>(EltTy)->getNumElements() == 3)
807  IsNewStructor = true;
808  else
809  IsOldStructor = true;
810  }
811 
812  PointerType *VoidPtrTy = Type::getInt8Ty(SrcGV->getContext())->getPointerTo();
813  if (IsOldStructor) {
814  auto &ST = *cast<StructType>(EltTy);
815  Type *Tys[3] = {ST.getElementType(0), ST.getElementType(1), VoidPtrTy};
816  EltTy = StructType::get(SrcGV->getContext(), Tys, false);
817  }
818 
819  uint64_t DstNumElements = 0;
820  if (DstGV) {
821  ArrayType *DstTy = cast<ArrayType>(DstGV->getValueType());
822  DstNumElements = DstTy->getNumElements();
823 
824  if (!SrcGV->hasAppendingLinkage() || !DstGV->hasAppendingLinkage())
825  return stringErr(
826  "Linking globals named '" + SrcGV->getName() +
827  "': can only link appending global with another appending "
828  "global!");
829 
830  // Check to see that they two arrays agree on type.
831  if (EltTy != DstTy->getElementType())
832  return stringErr("Appending variables with different element types!");
833  if (DstGV->isConstant() != SrcGV->isConstant())
834  return stringErr("Appending variables linked with different const'ness!");
835 
836  if (DstGV->getAlignment() != SrcGV->getAlignment())
837  return stringErr(
838  "Appending variables with different alignment need to be linked!");
839 
840  if (DstGV->getVisibility() != SrcGV->getVisibility())
841  return stringErr(
842  "Appending variables with different visibility need to be linked!");
843 
844  if (DstGV->hasGlobalUnnamedAddr() != SrcGV->hasGlobalUnnamedAddr())
845  return stringErr(
846  "Appending variables with different unnamed_addr need to be linked!");
847 
848  if (DstGV->getSection() != SrcGV->getSection())
849  return stringErr(
850  "Appending variables with different section name need to be linked!");
851  }
852 
853  SmallVector<Constant *, 16> SrcElements;
854  getArrayElements(SrcGV->getInitializer(), SrcElements);
855 
856  if (IsNewStructor) {
857  auto It = remove_if(SrcElements, [this](Constant *E) {
858  auto *Key =
860  if (!Key)
861  return false;
862  GlobalValue *DGV = getLinkedToGlobal(Key);
863  return !shouldLink(DGV, *Key);
864  });
865  SrcElements.erase(It, SrcElements.end());
866  }
867  uint64_t NewSize = DstNumElements + SrcElements.size();
868  ArrayType *NewType = ArrayType::get(EltTy, NewSize);
869 
870  // Create the new global variable.
871  GlobalVariable *NG = new GlobalVariable(
872  DstM, NewType, SrcGV->isConstant(), SrcGV->getLinkage(),
873  /*init*/ nullptr, /*name*/ "", DstGV, SrcGV->getThreadLocalMode(),
874  SrcGV->getType()->getAddressSpace());
875 
876  NG->copyAttributesFrom(SrcGV);
877  forceRenaming(NG, SrcGV->getName());
878 
879  Constant *Ret = ConstantExpr::getBitCast(NG, TypeMap.get(SrcGV->getType()));
880 
881  Mapper.scheduleMapAppendingVariable(*NG,
882  DstGV ? DstGV->getInitializer() : nullptr,
883  IsOldStructor, SrcElements);
884 
885  // Replace any uses of the two global variables with uses of the new
886  // global.
887  if (DstGV) {
889  DstGV->eraseFromParent();
890  }
891 
892  return Ret;
893 }
894 
895 bool IRLinker::shouldLink(GlobalValue *DGV, GlobalValue &SGV) {
896  if (ValuesToLink.count(&SGV) || SGV.hasLocalLinkage())
897  return true;
898 
899  if (DGV && !DGV->isDeclarationForLinker())
900  return false;
901 
902  if (SGV.isDeclaration() || DoneLinkingBodies)
903  return false;
904 
905  // Callback to the client to give a chance to lazily add the Global to the
906  // list of value to link.
907  bool LazilyAdded = false;
908  AddLazyFor(SGV, [this, &LazilyAdded](GlobalValue &GV) {
909  maybeAdd(&GV);
910  LazilyAdded = true;
911  });
912  return LazilyAdded;
913 }
914 
915 Expected<Constant *> IRLinker::linkGlobalValueProto(GlobalValue *SGV,
916  bool ForAlias) {
917  GlobalValue *DGV = getLinkedToGlobal(SGV);
918 
919  bool ShouldLink = shouldLink(DGV, *SGV);
920 
921  // just missing from map
922  if (ShouldLink) {
923  auto I = ValueMap.find(SGV);
924  if (I != ValueMap.end())
925  return cast<Constant>(I->second);
926 
927  I = AliasValueMap.find(SGV);
928  if (I != AliasValueMap.end())
929  return cast<Constant>(I->second);
930  }
931 
932  if (!ShouldLink && ForAlias)
933  DGV = nullptr;
934 
935  // Handle the ultra special appending linkage case first.
936  assert(!DGV || SGV->hasAppendingLinkage() == DGV->hasAppendingLinkage());
937  if (SGV->hasAppendingLinkage())
938  return linkAppendingVarProto(cast_or_null<GlobalVariable>(DGV),
939  cast<GlobalVariable>(SGV));
940 
941  GlobalValue *NewGV;
942  if (DGV && !ShouldLink) {
943  NewGV = DGV;
944  } else {
945  // If we are done linking global value bodies (i.e. we are performing
946  // metadata linking), don't link in the global value due to this
947  // reference, simply map it to null.
948  if (DoneLinkingBodies)
949  return nullptr;
950 
951  NewGV = copyGlobalValueProto(SGV, ShouldLink || ForAlias);
952  if (ShouldLink || !ForAlias)
953  forceRenaming(NewGV, SGV->getName());
954  }
955 
956  // Overloaded intrinsics have overloaded types names as part of their
957  // names. If we renamed overloaded types we should rename the intrinsic
958  // as well.
959  if (Function *F = dyn_cast<Function>(NewGV))
960  if (auto Remangled = Intrinsic::remangleIntrinsicFunction(F))
961  NewGV = Remangled.getValue();
962 
963  if (ShouldLink || ForAlias) {
964  if (const Comdat *SC = SGV->getComdat()) {
965  if (auto *GO = dyn_cast<GlobalObject>(NewGV)) {
966  Comdat *DC = DstM.getOrInsertComdat(SC->getName());
967  DC->setSelectionKind(SC->getSelectionKind());
968  GO->setComdat(DC);
969  }
970  }
971  }
972 
973  if (!ShouldLink && ForAlias)
975 
976  Constant *C = NewGV;
977  // Only create a bitcast if necessary. In particular, with
978  // DebugTypeODRUniquing we may reach metadata in the destination module
979  // containing a GV from the source module, in which case SGV will be
980  // the same as DGV and NewGV, and TypeMap.get() will assert since it
981  // assumes it is being invoked on a type in the source module.
982  if (DGV && NewGV != SGV)
983  C = ConstantExpr::getBitCast(NewGV, TypeMap.get(SGV->getType()));
984 
985  if (DGV && NewGV != DGV) {
987  DGV->eraseFromParent();
988  }
989 
990  return C;
991 }
992 
993 /// Update the initializers in the Dest module now that all globals that may be
994 /// referenced are in Dest.
995 void IRLinker::linkGlobalVariable(GlobalVariable &Dst, GlobalVariable &Src) {
996  // Figure out what the initializer looks like in the dest module.
997  Mapper.scheduleMapGlobalInitializer(Dst, *Src.getInitializer());
998 }
999 
1000 /// Copy the source function over into the dest function and fix up references
1001 /// to values. At this point we know that Dest is an external function, and
1002 /// that Src is not.
1003 Error IRLinker::linkFunctionBody(Function &Dst, Function &Src) {
1004  assert(Dst.isDeclaration() && !Src.isDeclaration());
1005 
1006  // Materialize if needed.
1007  if (Error Err = Src.materialize())
1008  return Err;
1009 
1010  // Link in the operands without remapping.
1011  if (Src.hasPrefixData())
1012  Dst.setPrefixData(Src.getPrefixData());
1013  if (Src.hasPrologueData())
1014  Dst.setPrologueData(Src.getPrologueData());
1015  if (Src.hasPersonalityFn())
1017 
1018  // Copy over the metadata attachments without remapping.
1019  Dst.copyMetadata(&Src, 0);
1020 
1021  // Steal arguments and splice the body of Src into Dst.
1022  Dst.stealArgumentListFrom(Src);
1023  Dst.getBasicBlockList().splice(Dst.end(), Src.getBasicBlockList());
1024 
1025  // Everything has been moved over. Remap it.
1026  Mapper.scheduleRemapFunction(Dst);
1027  return Error::success();
1028 }
1029 
1030 void IRLinker::linkAliasBody(GlobalAlias &Dst, GlobalAlias &Src) {
1031  Mapper.scheduleMapGlobalAliasee(Dst, *Src.getAliasee(), AliasMCID);
1032 }
1033 
1034 Error IRLinker::linkGlobalValueBody(GlobalValue &Dst, GlobalValue &Src) {
1035  if (auto *F = dyn_cast<Function>(&Src))
1036  return linkFunctionBody(cast<Function>(Dst), *F);
1037  if (auto *GVar = dyn_cast<GlobalVariable>(&Src)) {
1038  linkGlobalVariable(cast<GlobalVariable>(Dst), *GVar);
1039  return Error::success();
1040  }
1041  linkAliasBody(cast<GlobalAlias>(Dst), cast<GlobalAlias>(Src));
1042  return Error::success();
1043 }
1044 
1045 void IRLinker::prepareCompileUnitsForImport() {
1046  NamedMDNode *SrcCompileUnits = SrcM->getNamedMetadata("llvm.dbg.cu");
1047  if (!SrcCompileUnits)
1048  return;
1049  // When importing for ThinLTO, prevent importing of types listed on
1050  // the DICompileUnit that we don't need a copy of in the importing
1051  // module. They will be emitted by the originating module.
1052  for (unsigned I = 0, E = SrcCompileUnits->getNumOperands(); I != E; ++I) {
1053  auto *CU = cast<DICompileUnit>(SrcCompileUnits->getOperand(I));
1054  assert(CU && "Expected valid compile unit");
1055  // Enums, macros, and retained types don't need to be listed on the
1056  // imported DICompileUnit. This means they will only be imported
1057  // if reached from the mapped IR. Do this by setting their value map
1058  // entries to nullptr, which will automatically prevent their importing
1059  // when reached from the DICompileUnit during metadata mapping.
1060  ValueMap.MD()[CU->getRawEnumTypes()].reset(nullptr);
1061  ValueMap.MD()[CU->getRawMacros()].reset(nullptr);
1062  ValueMap.MD()[CU->getRawRetainedTypes()].reset(nullptr);
1063  // We import global variables only temporarily in order for instcombine
1064  // and globalopt to perform constant folding and static constructor
1065  // evaluation. After that elim-avail-extern will covert imported globals
1066  // back to declarations, so we don't need debug info for them.
1067  ValueMap.MD()[CU->getRawGlobalVariables()].reset(nullptr);
1068 
1069  // Imported entities only need to be mapped in if they have local
1070  // scope, as those might correspond to an imported entity inside a
1071  // function being imported (any locally scoped imported entities that
1072  // don't end up referenced by an imported function will not be emitted
1073  // into the object). Imported entities not in a local scope
1074  // (e.g. on the namespace) only need to be emitted by the originating
1075  // module. Create a list of the locally scoped imported entities, and
1076  // replace the source CUs imported entity list with the new list, so
1077  // only those are mapped in.
1078  // FIXME: Locally-scoped imported entities could be moved to the
1079  // functions they are local to instead of listing them on the CU, and
1080  // we would naturally only link in those needed by function importing.
1081  SmallVector<TrackingMDNodeRef, 4> AllImportedModules;
1082  bool ReplaceImportedEntities = false;
1083  for (auto *IE : CU->getImportedEntities()) {
1084  DIScope *Scope = IE->getScope();
1085  assert(Scope && "Invalid Scope encoding!");
1086  if (isa<DILocalScope>(Scope))
1087  AllImportedModules.emplace_back(IE);
1088  else
1089  ReplaceImportedEntities = true;
1090  }
1091  if (ReplaceImportedEntities) {
1092  if (!AllImportedModules.empty())
1093  CU->replaceImportedEntities(MDTuple::get(
1094  CU->getContext(),
1095  SmallVector<Metadata *, 16>(AllImportedModules.begin(),
1096  AllImportedModules.end())));
1097  else
1098  // If there were no local scope imported entities, we can map
1099  // the whole list to nullptr.
1100  ValueMap.MD()[CU->getRawImportedEntities()].reset(nullptr);
1101  }
1102  }
1103 }
1104 
1105 /// Insert all of the named MDNodes in Src into the Dest module.
1106 void IRLinker::linkNamedMDNodes() {
1107  const NamedMDNode *SrcModFlags = SrcM->getModuleFlagsMetadata();
1108  for (const NamedMDNode &NMD : SrcM->named_metadata()) {
1109  // Don't link module flags here. Do them separately.
1110  if (&NMD == SrcModFlags)
1111  continue;
1112  NamedMDNode *DestNMD = DstM.getOrInsertNamedMetadata(NMD.getName());
1113  // Add Src elements into Dest node.
1114  for (const MDNode *Op : NMD.operands())
1115  DestNMD->addOperand(Mapper.mapMDNode(*Op));
1116  }
1117 }
1118 
1119 /// Merge the linker flags in Src into the Dest module.
1120 Error IRLinker::linkModuleFlagsMetadata() {
1121  // If the source module has no module flags, we are done.
1122  const NamedMDNode *SrcModFlags = SrcM->getModuleFlagsMetadata();
1123  if (!SrcModFlags)
1124  return Error::success();
1125 
1126  // If the destination module doesn't have module flags yet, then just copy
1127  // over the source module's flags.
1128  NamedMDNode *DstModFlags = DstM.getOrInsertModuleFlagsMetadata();
1129  if (DstModFlags->getNumOperands() == 0) {
1130  for (unsigned I = 0, E = SrcModFlags->getNumOperands(); I != E; ++I)
1131  DstModFlags->addOperand(SrcModFlags->getOperand(I));
1132 
1133  return Error::success();
1134  }
1135 
1136  // First build a map of the existing module flags and requirements.
1138  SmallSetVector<MDNode *, 16> Requirements;
1139  for (unsigned I = 0, E = DstModFlags->getNumOperands(); I != E; ++I) {
1140  MDNode *Op = DstModFlags->getOperand(I);
1141  ConstantInt *Behavior = mdconst::extract<ConstantInt>(Op->getOperand(0));
1142  MDString *ID = cast<MDString>(Op->getOperand(1));
1143 
1144  if (Behavior->getZExtValue() == Module::Require) {
1145  Requirements.insert(cast<MDNode>(Op->getOperand(2)));
1146  } else {
1147  Flags[ID] = std::make_pair(Op, I);
1148  }
1149  }
1150 
1151  // Merge in the flags from the source module, and also collect its set of
1152  // requirements.
1153  for (unsigned I = 0, E = SrcModFlags->getNumOperands(); I != E; ++I) {
1154  MDNode *SrcOp = SrcModFlags->getOperand(I);
1155  ConstantInt *SrcBehavior =
1156  mdconst::extract<ConstantInt>(SrcOp->getOperand(0));
1157  MDString *ID = cast<MDString>(SrcOp->getOperand(1));
1158  MDNode *DstOp;
1159  unsigned DstIndex;
1160  std::tie(DstOp, DstIndex) = Flags.lookup(ID);
1161  unsigned SrcBehaviorValue = SrcBehavior->getZExtValue();
1162 
1163  // If this is a requirement, add it and continue.
1164  if (SrcBehaviorValue == Module::Require) {
1165  // If the destination module does not already have this requirement, add
1166  // it.
1167  if (Requirements.insert(cast<MDNode>(SrcOp->getOperand(2)))) {
1168  DstModFlags->addOperand(SrcOp);
1169  }
1170  continue;
1171  }
1172 
1173  // If there is no existing flag with this ID, just add it.
1174  if (!DstOp) {
1175  Flags[ID] = std::make_pair(SrcOp, DstModFlags->getNumOperands());
1176  DstModFlags->addOperand(SrcOp);
1177  continue;
1178  }
1179 
1180  // Otherwise, perform a merge.
1181  ConstantInt *DstBehavior =
1182  mdconst::extract<ConstantInt>(DstOp->getOperand(0));
1183  unsigned DstBehaviorValue = DstBehavior->getZExtValue();
1184 
1185  auto overrideDstValue = [&]() {
1186  DstModFlags->setOperand(DstIndex, SrcOp);
1187  Flags[ID].first = SrcOp;
1188  };
1189 
1190  // If either flag has override behavior, handle it first.
1191  if (DstBehaviorValue == Module::Override) {
1192  // Diagnose inconsistent flags which both have override behavior.
1193  if (SrcBehaviorValue == Module::Override &&
1194  SrcOp->getOperand(2) != DstOp->getOperand(2))
1195  return stringErr("linking module flags '" + ID->getString() +
1196  "': IDs have conflicting override values");
1197  continue;
1198  } else if (SrcBehaviorValue == Module::Override) {
1199  // Update the destination flag to that of the source.
1200  overrideDstValue();
1201  continue;
1202  }
1203 
1204  // Diagnose inconsistent merge behavior types.
1205  if (SrcBehaviorValue != DstBehaviorValue)
1206  return stringErr("linking module flags '" + ID->getString() +
1207  "': IDs have conflicting behaviors");
1208 
1209  auto replaceDstValue = [&](MDNode *New) {
1210  Metadata *FlagOps[] = {DstOp->getOperand(0), ID, New};
1211  MDNode *Flag = MDNode::get(DstM.getContext(), FlagOps);
1212  DstModFlags->setOperand(DstIndex, Flag);
1213  Flags[ID].first = Flag;
1214  };
1215 
1216  // Perform the merge for standard behavior types.
1217  switch (SrcBehaviorValue) {
1218  case Module::Require:
1219  case Module::Override:
1220  llvm_unreachable("not possible");
1221  case Module::Error: {
1222  // Emit an error if the values differ.
1223  if (SrcOp->getOperand(2) != DstOp->getOperand(2))
1224  return stringErr("linking module flags '" + ID->getString() +
1225  "': IDs have conflicting values");
1226  continue;
1227  }
1228  case Module::Warning: {
1229  // Emit a warning if the values differ.
1230  if (SrcOp->getOperand(2) != DstOp->getOperand(2)) {
1231  emitWarning("linking module flags '" + ID->getString() +
1232  "': IDs have conflicting values");
1233  }
1234  continue;
1235  }
1236  case Module::Max: {
1237  ConstantInt *DstValue =
1238  mdconst::extract<ConstantInt>(DstOp->getOperand(2));
1239  ConstantInt *SrcValue =
1240  mdconst::extract<ConstantInt>(SrcOp->getOperand(2));
1241  if (SrcValue->getZExtValue() > DstValue->getZExtValue())
1242  overrideDstValue();
1243  break;
1244  }
1245  case Module::Append: {
1246  MDNode *DstValue = cast<MDNode>(DstOp->getOperand(2));
1247  MDNode *SrcValue = cast<MDNode>(SrcOp->getOperand(2));
1249  MDs.reserve(DstValue->getNumOperands() + SrcValue->getNumOperands());
1250  MDs.append(DstValue->op_begin(), DstValue->op_end());
1251  MDs.append(SrcValue->op_begin(), SrcValue->op_end());
1252 
1253  replaceDstValue(MDNode::get(DstM.getContext(), MDs));
1254  break;
1255  }
1256  case Module::AppendUnique: {
1258  MDNode *DstValue = cast<MDNode>(DstOp->getOperand(2));
1259  MDNode *SrcValue = cast<MDNode>(SrcOp->getOperand(2));
1260  Elts.insert(DstValue->op_begin(), DstValue->op_end());
1261  Elts.insert(SrcValue->op_begin(), SrcValue->op_end());
1262 
1263  replaceDstValue(MDNode::get(DstM.getContext(),
1264  makeArrayRef(Elts.begin(), Elts.end())));
1265  break;
1266  }
1267  }
1268  }
1269 
1270  // Check all of the requirements.
1271  for (unsigned I = 0, E = Requirements.size(); I != E; ++I) {
1272  MDNode *Requirement = Requirements[I];
1273  MDString *Flag = cast<MDString>(Requirement->getOperand(0));
1274  Metadata *ReqValue = Requirement->getOperand(1);
1275 
1276  MDNode *Op = Flags[Flag].first;
1277  if (!Op || Op->getOperand(2) != ReqValue)
1278  return stringErr("linking module flags '" + Flag->getString() +
1279  "': does not have the required value");
1280  }
1281  return Error::success();
1282 }
1283 
1284 /// Return InlineAsm adjusted with target-specific directives if required.
1285 /// For ARM and Thumb, we have to add directives to select the appropriate ISA
1286 /// to support mixing module-level inline assembly from ARM and Thumb modules.
1287 static std::string adjustInlineAsm(const std::string &InlineAsm,
1288  const Triple &Triple) {
1289  if (Triple.getArch() == Triple::thumb || Triple.getArch() == Triple::thumbeb)
1290  return ".text\n.balign 2\n.thumb\n" + InlineAsm;
1291  if (Triple.getArch() == Triple::arm || Triple.getArch() == Triple::armeb)
1292  return ".text\n.balign 4\n.arm\n" + InlineAsm;
1293  return InlineAsm;
1294 }
1295 
1296 Error IRLinker::run() {
1297  // Ensure metadata materialized before value mapping.
1298  if (SrcM->getMaterializer())
1299  if (Error Err = SrcM->getMaterializer()->materializeMetadata())
1300  return Err;
1301 
1302  // Inherit the target data from the source module if the destination module
1303  // doesn't have one already.
1304  if (DstM.getDataLayout().isDefault())
1305  DstM.setDataLayout(SrcM->getDataLayout());
1306 
1307  if (SrcM->getDataLayout() != DstM.getDataLayout()) {
1308  emitWarning("Linking two modules of different data layouts: '" +
1309  SrcM->getModuleIdentifier() + "' is '" +
1310  SrcM->getDataLayoutStr() + "' whereas '" +
1311  DstM.getModuleIdentifier() + "' is '" +
1312  DstM.getDataLayoutStr() + "'\n");
1313  }
1314 
1315  // Copy the target triple from the source to dest if the dest's is empty.
1316  if (DstM.getTargetTriple().empty() && !SrcM->getTargetTriple().empty())
1317  DstM.setTargetTriple(SrcM->getTargetTriple());
1318 
1319  Triple SrcTriple(SrcM->getTargetTriple()), DstTriple(DstM.getTargetTriple());
1320 
1321  if (!SrcM->getTargetTriple().empty()&&
1322  !SrcTriple.isCompatibleWith(DstTriple))
1323  emitWarning("Linking two modules of different target triples: " +
1324  SrcM->getModuleIdentifier() + "' is '" +
1325  SrcM->getTargetTriple() + "' whereas '" +
1326  DstM.getModuleIdentifier() + "' is '" + DstM.getTargetTriple() +
1327  "'\n");
1328 
1329  DstM.setTargetTriple(SrcTriple.merge(DstTriple));
1330 
1331  // Append the module inline asm string.
1332  if (!IsPerformingImport && !SrcM->getModuleInlineAsm().empty()) {
1333  std::string SrcModuleInlineAsm = adjustInlineAsm(SrcM->getModuleInlineAsm(),
1334  SrcTriple);
1335  if (DstM.getModuleInlineAsm().empty())
1336  DstM.setModuleInlineAsm(SrcModuleInlineAsm);
1337  else
1338  DstM.setModuleInlineAsm(DstM.getModuleInlineAsm() + "\n" +
1339  SrcModuleInlineAsm);
1340  }
1341 
1342  // Loop over all of the linked values to compute type mappings.
1343  computeTypeMapping();
1344 
1345  std::reverse(Worklist.begin(), Worklist.end());
1346  while (!Worklist.empty()) {
1347  GlobalValue *GV = Worklist.back();
1348  Worklist.pop_back();
1349 
1350  // Already mapped.
1351  if (ValueMap.find(GV) != ValueMap.end() ||
1352  AliasValueMap.find(GV) != AliasValueMap.end())
1353  continue;
1354 
1355  assert(!GV->isDeclaration());
1356  Mapper.mapValue(*GV);
1357  if (FoundError)
1358  return std::move(*FoundError);
1359  }
1360 
1361  // Note that we are done linking global value bodies. This prevents
1362  // metadata linking from creating new references.
1363  DoneLinkingBodies = true;
1364  Mapper.addFlags(RF_NullMapMissingGlobalValues);
1365 
1366  // Remap all of the named MDNodes in Src into the DstM module. We do this
1367  // after linking GlobalValues so that MDNodes that reference GlobalValues
1368  // are properly remapped.
1369  linkNamedMDNodes();
1370 
1371  // Merge the module flags into the DstM module.
1372  return linkModuleFlagsMetadata();
1373 }
1374 
1376  : ETypes(E), IsPacked(P) {}
1377 
1379  : ETypes(ST->elements()), IsPacked(ST->isPacked()) {}
1380 
1382  return IsPacked == That.IsPacked && ETypes == That.ETypes;
1383 }
1384 
1386  return !this->operator==(That);
1387 }
1388 
1389 StructType *IRMover::StructTypeKeyInfo::getEmptyKey() {
1391 }
1392 
1393 StructType *IRMover::StructTypeKeyInfo::getTombstoneKey() {
1395 }
1396 
1397 unsigned IRMover::StructTypeKeyInfo::getHashValue(const KeyTy &Key) {
1398  return hash_combine(hash_combine_range(Key.ETypes.begin(), Key.ETypes.end()),
1399  Key.IsPacked);
1400 }
1401 
1402 unsigned IRMover::StructTypeKeyInfo::getHashValue(const StructType *ST) {
1403  return getHashValue(KeyTy(ST));
1404 }
1405 
1407  const StructType *RHS) {
1408  if (RHS == getEmptyKey() || RHS == getTombstoneKey())
1409  return false;
1410  return LHS == KeyTy(RHS);
1411 }
1412 
1414  const StructType *RHS) {
1415  if (RHS == getEmptyKey() || RHS == getTombstoneKey())
1416  return LHS == RHS;
1417  return KeyTy(LHS) == KeyTy(RHS);
1418 }
1419 
1421  assert(!Ty->isOpaque());
1422  NonOpaqueStructTypes.insert(Ty);
1423 }
1424 
1426  assert(!Ty->isOpaque());
1427  NonOpaqueStructTypes.insert(Ty);
1428  bool Removed = OpaqueStructTypes.erase(Ty);
1429  (void)Removed;
1430  assert(Removed);
1431 }
1432 
1434  assert(Ty->isOpaque());
1435  OpaqueStructTypes.insert(Ty);
1436 }
1437 
1438 StructType *
1440  bool IsPacked) {
1441  IRMover::StructTypeKeyInfo::KeyTy Key(ETypes, IsPacked);
1442  auto I = NonOpaqueStructTypes.find_as(Key);
1443  return I == NonOpaqueStructTypes.end() ? nullptr : *I;
1444 }
1445 
1447  if (Ty->isOpaque())
1448  return OpaqueStructTypes.count(Ty);
1449  auto I = NonOpaqueStructTypes.find(Ty);
1450  return I == NonOpaqueStructTypes.end() ? false : *I == Ty;
1451 }
1452 
1453 IRMover::IRMover(Module &M) : Composite(M) {
1454  TypeFinder StructTypes;
1455  StructTypes.run(M, /* OnlyNamed */ false);
1456  for (StructType *Ty : StructTypes) {
1457  if (Ty->isOpaque())
1458  IdentifiedStructTypes.addOpaque(Ty);
1459  else
1460  IdentifiedStructTypes.addNonOpaque(Ty);
1461  }
1462  // Self-map metadatas in the destination module. This is needed when
1463  // DebugTypeODRUniquing is enabled on the LLVMContext, since metadata in the
1464  // destination module may be reached from the source module.
1465  for (auto *MD : StructTypes.getVisitedMetadata()) {
1466  SharedMDs[MD].reset(const_cast<MDNode *>(MD));
1467  }
1468 }
1469 
1471  std::unique_ptr<Module> Src, ArrayRef<GlobalValue *> ValuesToLink,
1472  std::function<void(GlobalValue &, ValueAdder Add)> AddLazyFor,
1473  bool IsPerformingImport) {
1474  IRLinker TheIRLinker(Composite, SharedMDs, IdentifiedStructTypes,
1475  std::move(Src), ValuesToLink, std::move(AddLazyFor),
1476  IsPerformingImport);
1477  Error E = TheIRLinker.run();
1478  Composite.dropTriviallyDeadConstantArrays();
1479  return E;
1480 }
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:1375
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:137
iterator end()
Definition: Function.h:644
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:714
bool hasPrologueData() const
Check whether this function has prologue data.
Definition: Function.h:706
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:1425
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:545
15: Pointers
Definition: Type.h:75
void reserve(size_type N)
Definition: SmallVector.h:377
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:1308
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:1454
A tuple of MDNodes.
Definition: Metadata.h:1323
bool hasPrefixData() const
Check whether this function has prefix data.
Definition: Function.h:697
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:1298
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:1205
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:1470
ArchType getArch() const
getArch - Get the parsed architecture type of this triple.
Definition: Triple.h:285
#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:1385
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:688
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:118
Constant * getAggregateElement(unsigned Elt) const
For aggregates (struct/array/vector) return the constant that corresponds to the specified element if...
Definition: Constants.cpp:338
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:1750
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:288
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:117
unsigned getNumContainedTypes() const
Return the number of types in the derived type.
Definition: Type.h:339
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
bool isODRUniquingDebugTypes() const
Whether there is a string map for uniquing debug info identifiers across the context.
Optional< MDMapT > & getMDMap()
Definition: ValueMap.h:122
void splice(iterator where, iplist_impl &L2)
Definition: ilist.h:329
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:948
Error materialize()
Make sure this GlobalValue is fully read.
Definition: Globals.cpp:50
const Constant * stripPointerCasts() const
Definition: Constant.h:173
iterator erase(const_iterator CI)
Definition: SmallVector.h:446
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:783
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:321
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:861
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:351
bool operator==(const KeyTy &that) const
Definition: IRMover.cpp:1381
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:150
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:694
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:348
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:1453
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:121
bool isPacked() const
Definition: DerivedTypes.h:261
bool isFunctionTy() const
True if this is an instance of FunctionType.
Definition: Type.h:215
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:653
LLVM_NODISCARD bool empty() const
Definition: SmallVector.h:62
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:1313
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:619
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:1439
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:1288
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:1287
static void forceRenaming(GlobalValue *GV, StringRef Name)
The LLVM SymbolTable class autorenames globals that conflict in the symbol table. ...
Definition: IRMover.cpp:534
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:1293
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:333
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:1303
void resize(size_type N)
Definition: SmallVector.h:352
const Constant * getAliasee() const
Definition: GlobalAlias.h:78