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