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