LLVM  9.0.0svn
ValueMapper.cpp
Go to the documentation of this file.
1 //===- ValueMapper.cpp - Interface shared by lib/Transforms/Utils ---------===//
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 // This file defines the MapValue function, which is shared by various parts of
10 // the lib/Transforms/Utils library.
11 //
12 //===----------------------------------------------------------------------===//
13 
15 #include "llvm/ADT/ArrayRef.h"
16 #include "llvm/ADT/DenseMap.h"
17 #include "llvm/ADT/DenseSet.h"
18 #include "llvm/ADT/None.h"
19 #include "llvm/ADT/Optional.h"
20 #include "llvm/ADT/STLExtras.h"
21 #include "llvm/ADT/SmallVector.h"
22 #include "llvm/IR/Argument.h"
23 #include "llvm/IR/BasicBlock.h"
24 #include "llvm/IR/CallSite.h"
25 #include "llvm/IR/Constant.h"
26 #include "llvm/IR/Constants.h"
28 #include "llvm/IR/DerivedTypes.h"
29 #include "llvm/IR/Function.h"
30 #include "llvm/IR/GlobalAlias.h"
31 #include "llvm/IR/GlobalObject.h"
32 #include "llvm/IR/GlobalVariable.h"
33 #include "llvm/IR/InlineAsm.h"
34 #include "llvm/IR/Instruction.h"
35 #include "llvm/IR/Instructions.h"
36 #include "llvm/IR/Metadata.h"
37 #include "llvm/IR/Operator.h"
38 #include "llvm/IR/Type.h"
39 #include "llvm/IR/Value.h"
40 #include "llvm/Support/Casting.h"
41 #include <cassert>
42 #include <limits>
43 #include <memory>
44 #include <utility>
45 
46 using namespace llvm;
47 
48 // Out of line method to get vtable etc for class.
49 void ValueMapTypeRemapper::anchor() {}
50 void ValueMaterializer::anchor() {}
51 
52 namespace {
53 
54 /// A basic block used in a BlockAddress whose function body is not yet
55 /// materialized.
56 struct DelayedBasicBlock {
57  BasicBlock *OldBB;
58  std::unique_ptr<BasicBlock> TempBB;
59 
60  DelayedBasicBlock(const BlockAddress &Old)
61  : OldBB(Old.getBasicBlock()),
62  TempBB(BasicBlock::Create(Old.getContext())) {}
63 };
64 
65 struct WorklistEntry {
66  enum EntryKind {
67  MapGlobalInit,
68  MapAppendingVar,
69  MapGlobalAliasee,
71  };
72  struct GVInitTy {
73  GlobalVariable *GV;
74  Constant *Init;
75  };
76  struct AppendingGVTy {
77  GlobalVariable *GV;
78  Constant *InitPrefix;
79  };
80  struct GlobalAliaseeTy {
81  GlobalAlias *GA;
82  Constant *Aliasee;
83  };
84 
85  unsigned Kind : 2;
86  unsigned MCID : 29;
87  unsigned AppendingGVIsOldCtorDtor : 1;
88  unsigned AppendingGVNumNewMembers;
89  union {
90  GVInitTy GVInit;
91  AppendingGVTy AppendingGV;
92  GlobalAliaseeTy GlobalAliasee;
93  Function *RemapF;
94  } Data;
95 };
96 
97 struct MappingContext {
99  ValueMaterializer *Materializer = nullptr;
100 
101  /// Construct a MappingContext with a value map and materializer.
102  explicit MappingContext(ValueToValueMapTy &VM,
103  ValueMaterializer *Materializer = nullptr)
104  : VM(&VM), Materializer(Materializer) {}
105 };
106 
107 class Mapper {
108  friend class MDNodeMapper;
109 
110 #ifndef NDEBUG
111  DenseSet<GlobalValue *> AlreadyScheduled;
112 #endif
113 
114  RemapFlags Flags;
115  ValueMapTypeRemapper *TypeMapper;
116  unsigned CurrentMCID = 0;
120  SmallVector<Constant *, 16> AppendingInits;
121 
122 public:
123  Mapper(ValueToValueMapTy &VM, RemapFlags Flags,
124  ValueMapTypeRemapper *TypeMapper, ValueMaterializer *Materializer)
125  : Flags(Flags), TypeMapper(TypeMapper),
126  MCs(1, MappingContext(VM, Materializer)) {}
127 
128  /// ValueMapper should explicitly call \a flush() before destruction.
129  ~Mapper() { assert(!hasWorkToDo() && "Expected to be flushed"); }
130 
131  bool hasWorkToDo() const { return !Worklist.empty(); }
132 
133  unsigned
134  registerAlternateMappingContext(ValueToValueMapTy &VM,
135  ValueMaterializer *Materializer = nullptr) {
136  MCs.push_back(MappingContext(VM, Materializer));
137  return MCs.size() - 1;
138  }
139 
140  void addFlags(RemapFlags Flags);
141 
142  void remapGlobalObjectMetadata(GlobalObject &GO);
143 
144  Value *mapValue(const Value *V);
146  void remapFunction(Function &F);
147 
148  Constant *mapConstant(const Constant *C) {
149  return cast_or_null<Constant>(mapValue(C));
150  }
151 
152  /// Map metadata.
153  ///
154  /// Find the mapping for MD. Guarantees that the return will be resolved
155  /// (not an MDNode, or MDNode::isResolved() returns true).
156  Metadata *mapMetadata(const Metadata *MD);
157 
158  void scheduleMapGlobalInitializer(GlobalVariable &GV, Constant &Init,
159  unsigned MCID);
160  void scheduleMapAppendingVariable(GlobalVariable &GV, Constant *InitPrefix,
161  bool IsOldCtorDtor,
162  ArrayRef<Constant *> NewMembers,
163  unsigned MCID);
164  void scheduleMapGlobalAliasee(GlobalAlias &GA, Constant &Aliasee,
165  unsigned MCID);
166  void scheduleRemapFunction(Function &F, unsigned MCID);
167 
168  void flush();
169 
170 private:
171  void mapGlobalInitializer(GlobalVariable &GV, Constant &Init);
172  void mapAppendingVariable(GlobalVariable &GV, Constant *InitPrefix,
173  bool IsOldCtorDtor,
174  ArrayRef<Constant *> NewMembers);
175  void mapGlobalAliasee(GlobalAlias &GA, Constant &Aliasee);
176  void remapFunction(Function &F, ValueToValueMapTy &VM);
177 
178  ValueToValueMapTy &getVM() { return *MCs[CurrentMCID].VM; }
179  ValueMaterializer *getMaterializer() { return MCs[CurrentMCID].Materializer; }
180 
181  Value *mapBlockAddress(const BlockAddress &BA);
182 
183  /// Map metadata that doesn't require visiting operands.
184  Optional<Metadata *> mapSimpleMetadata(const Metadata *MD);
185 
186  Metadata *mapToMetadata(const Metadata *Key, Metadata *Val);
187  Metadata *mapToSelf(const Metadata *MD);
188 };
189 
190 class MDNodeMapper {
191  Mapper &M;
192 
193  /// Data about a node in \a UniquedGraph.
194  struct Data {
195  bool HasChanged = false;
197  TempMDNode Placeholder;
198  };
199 
200  /// A graph of uniqued nodes.
201  struct UniquedGraph {
203  SmallVector<MDNode *, 16> POT; // Post-order traversal.
204 
205  /// Propagate changed operands through the post-order traversal.
206  ///
207  /// Iteratively update \a Data::HasChanged for each node based on \a
208  /// Data::HasChanged of its operands, until fixed point.
209  void propagateChanges();
210 
211  /// Get a forward reference to a node to use as an operand.
212  Metadata &getFwdReference(MDNode &Op);
213  };
214 
215  /// Worklist of distinct nodes whose operands need to be remapped.
216  SmallVector<MDNode *, 16> DistinctWorklist;
217 
218  // Storage for a UniquedGraph.
220  SmallVector<MDNode *, 16> POTStorage;
221 
222 public:
223  MDNodeMapper(Mapper &M) : M(M) {}
224 
225  /// Map a metadata node (and its transitive operands).
226  ///
227  /// Map all the (unmapped) nodes in the subgraph under \c N. The iterative
228  /// algorithm handles distinct nodes and uniqued node subgraphs using
229  /// different strategies.
230  ///
231  /// Distinct nodes are immediately mapped and added to \a DistinctWorklist
232  /// using \a mapDistinctNode(). Their mapping can always be computed
233  /// immediately without visiting operands, even if their operands change.
234  ///
235  /// The mapping for uniqued nodes depends on whether their operands change.
236  /// \a mapTopLevelUniquedNode() traverses the transitive uniqued subgraph of
237  /// a node to calculate uniqued node mappings in bulk. Distinct leafs are
238  /// added to \a DistinctWorklist with \a mapDistinctNode().
239  ///
240  /// After mapping \c N itself, this function remaps the operands of the
241  /// distinct nodes in \a DistinctWorklist until the entire subgraph under \c
242  /// N has been mapped.
243  Metadata *map(const MDNode &N);
244 
245 private:
246  /// Map a top-level uniqued node and the uniqued subgraph underneath it.
247  ///
248  /// This builds up a post-order traversal of the (unmapped) uniqued subgraph
249  /// underneath \c FirstN and calculates the nodes' mapping. Each node uses
250  /// the identity mapping (\a Mapper::mapToSelf()) as long as all of its
251  /// operands uses the identity mapping.
252  ///
253  /// The algorithm works as follows:
254  ///
255  /// 1. \a createPOT(): traverse the uniqued subgraph under \c FirstN and
256  /// save the post-order traversal in the given \a UniquedGraph, tracking
257  /// nodes' operands change.
258  ///
259  /// 2. \a UniquedGraph::propagateChanges(): propagate changed operands
260  /// through the \a UniquedGraph until fixed point, following the rule
261  /// that if a node changes, any node that references must also change.
262  ///
263  /// 3. \a mapNodesInPOT(): map the uniqued nodes, creating new uniqued nodes
264  /// (referencing new operands) where necessary.
265  Metadata *mapTopLevelUniquedNode(const MDNode &FirstN);
266 
267  /// Try to map the operand of an \a MDNode.
268  ///
269  /// If \c Op is already mapped, return the mapping. If it's not an \a
270  /// MDNode, compute and return the mapping. If it's a distinct \a MDNode,
271  /// return the result of \a mapDistinctNode().
272  ///
273  /// \return None if \c Op is an unmapped uniqued \a MDNode.
274  /// \post getMappedOp(Op) only returns None if this returns None.
275  Optional<Metadata *> tryToMapOperand(const Metadata *Op);
276 
277  /// Map a distinct node.
278  ///
279  /// Return the mapping for the distinct node \c N, saving the result in \a
280  /// DistinctWorklist for later remapping.
281  ///
282  /// \pre \c N is not yet mapped.
283  /// \pre \c N.isDistinct().
284  MDNode *mapDistinctNode(const MDNode &N);
285 
286  /// Get a previously mapped node.
288 
289  /// Create a post-order traversal of an unmapped uniqued node subgraph.
290  ///
291  /// This traverses the metadata graph deeply enough to map \c FirstN. It
292  /// uses \a tryToMapOperand() (via \a Mapper::mapSimplifiedNode()), so any
293  /// metadata that has already been mapped will not be part of the POT.
294  ///
295  /// Each node that has a changed operand from outside the graph (e.g., a
296  /// distinct node, an already-mapped uniqued node, or \a ConstantAsMetadata)
297  /// is marked with \a Data::HasChanged.
298  ///
299  /// \return \c true if any nodes in \c G have \a Data::HasChanged.
300  /// \post \c G.POT is a post-order traversal ending with \c FirstN.
301  /// \post \a Data::hasChanged in \c G.Info indicates whether any node needs
302  /// to change because of operands outside the graph.
303  bool createPOT(UniquedGraph &G, const MDNode &FirstN);
304 
305  /// Visit the operands of a uniqued node in the POT.
306  ///
307  /// Visit the operands in the range from \c I to \c E, returning the first
308  /// uniqued node we find that isn't yet in \c G. \c I is always advanced to
309  /// where to continue the loop through the operands.
310  ///
311  /// This sets \c HasChanged if any of the visited operands change.
312  MDNode *visitOperands(UniquedGraph &G, MDNode::op_iterator &I,
313  MDNode::op_iterator E, bool &HasChanged);
314 
315  /// Map all the nodes in the given uniqued graph.
316  ///
317  /// This visits all the nodes in \c G in post-order, using the identity
318  /// mapping or creating a new node depending on \a Data::HasChanged.
319  ///
320  /// \pre \a getMappedOp() returns None for nodes in \c G, but not for any of
321  /// their operands outside of \c G.
322  /// \pre \a Data::HasChanged is true for a node in \c G iff any of its
323  /// operands have changed.
324  /// \post \a getMappedOp() returns the mapped node for every node in \c G.
325  void mapNodesInPOT(UniquedGraph &G);
326 
327  /// Remap a node's operands using the given functor.
328  ///
329  /// Iterate through the operands of \c N and update them in place using \c
330  /// mapOperand.
331  ///
332  /// \pre N.isDistinct() or N.isTemporary().
333  template <class OperandMapper>
334  void remapOperands(MDNode &N, OperandMapper mapOperand);
335 };
336 
337 } // end anonymous namespace
338 
339 Value *Mapper::mapValue(const Value *V) {
340  ValueToValueMapTy::iterator I = getVM().find(V);
341 
342  // If the value already exists in the map, use it.
343  if (I != getVM().end()) {
344  assert(I->second && "Unexpected null mapping");
345  return I->second;
346  }
347 
348  // If we have a materializer and it can materialize a value, use that.
349  if (auto *Materializer = getMaterializer()) {
350  if (Value *NewV = Materializer->materialize(const_cast<Value *>(V))) {
351  getVM()[V] = NewV;
352  return NewV;
353  }
354  }
355 
356  // Global values do not need to be seeded into the VM if they
357  // are using the identity mapping.
358  if (isa<GlobalValue>(V)) {
359  if (Flags & RF_NullMapMissingGlobalValues)
360  return nullptr;
361  return getVM()[V] = const_cast<Value *>(V);
362  }
363 
364  if (const InlineAsm *IA = dyn_cast<InlineAsm>(V)) {
365  // Inline asm may need *type* remapping.
366  FunctionType *NewTy = IA->getFunctionType();
367  if (TypeMapper) {
368  NewTy = cast<FunctionType>(TypeMapper->remapType(NewTy));
369 
370  if (NewTy != IA->getFunctionType())
371  V = InlineAsm::get(NewTy, IA->getAsmString(), IA->getConstraintString(),
372  IA->hasSideEffects(), IA->isAlignStack());
373  }
374 
375  return getVM()[V] = const_cast<Value *>(V);
376  }
377 
378  if (const auto *MDV = dyn_cast<MetadataAsValue>(V)) {
379  const Metadata *MD = MDV->getMetadata();
380 
381  if (auto *LAM = dyn_cast<LocalAsMetadata>(MD)) {
382  // Look through to grab the local value.
383  if (Value *LV = mapValue(LAM->getValue())) {
384  if (V == LAM->getValue())
385  return const_cast<Value *>(V);
387  }
388 
389  // FIXME: always return nullptr once Verifier::verifyDominatesUse()
390  // ensures metadata operands only reference defined SSA values.
391  return (Flags & RF_IgnoreMissingLocals)
392  ? nullptr
394  MDTuple::get(V->getContext(), None));
395  }
396 
397  // If this is a module-level metadata and we know that nothing at the module
398  // level is changing, then use an identity mapping.
399  if (Flags & RF_NoModuleLevelChanges)
400  return getVM()[V] = const_cast<Value *>(V);
401 
402  // Map the metadata and turn it into a value.
403  auto *MappedMD = mapMetadata(MD);
404  if (MD == MappedMD)
405  return getVM()[V] = const_cast<Value *>(V);
406  return getVM()[V] = MetadataAsValue::get(V->getContext(), MappedMD);
407  }
408 
409  // Okay, this either must be a constant (which may or may not be mappable) or
410  // is something that is not in the mapping table.
411  Constant *C = const_cast<Constant*>(dyn_cast<Constant>(V));
412  if (!C)
413  return nullptr;
414 
415  if (BlockAddress *BA = dyn_cast<BlockAddress>(C))
416  return mapBlockAddress(*BA);
417 
418  auto mapValueOrNull = [this](Value *V) {
419  auto Mapped = mapValue(V);
420  assert((Mapped || (Flags & RF_NullMapMissingGlobalValues)) &&
421  "Unexpected null mapping for constant operand without "
422  "NullMapMissingGlobalValues flag");
423  return Mapped;
424  };
425 
426  // Otherwise, we have some other constant to remap. Start by checking to see
427  // if all operands have an identity remapping.
428  unsigned OpNo = 0, NumOperands = C->getNumOperands();
429  Value *Mapped = nullptr;
430  for (; OpNo != NumOperands; ++OpNo) {
431  Value *Op = C->getOperand(OpNo);
432  Mapped = mapValueOrNull(Op);
433  if (!Mapped)
434  return nullptr;
435  if (Mapped != Op)
436  break;
437  }
438 
439  // See if the type mapper wants to remap the type as well.
440  Type *NewTy = C->getType();
441  if (TypeMapper)
442  NewTy = TypeMapper->remapType(NewTy);
443 
444  // If the result type and all operands match up, then just insert an identity
445  // mapping.
446  if (OpNo == NumOperands && NewTy == C->getType())
447  return getVM()[V] = C;
448 
449  // Okay, we need to create a new constant. We've already processed some or
450  // all of the operands, set them all up now.
452  Ops.reserve(NumOperands);
453  for (unsigned j = 0; j != OpNo; ++j)
454  Ops.push_back(cast<Constant>(C->getOperand(j)));
455 
456  // If one of the operands mismatch, push it and the other mapped operands.
457  if (OpNo != NumOperands) {
458  Ops.push_back(cast<Constant>(Mapped));
459 
460  // Map the rest of the operands that aren't processed yet.
461  for (++OpNo; OpNo != NumOperands; ++OpNo) {
462  Mapped = mapValueOrNull(C->getOperand(OpNo));
463  if (!Mapped)
464  return nullptr;
465  Ops.push_back(cast<Constant>(Mapped));
466  }
467  }
468  Type *NewSrcTy = nullptr;
469  if (TypeMapper)
470  if (auto *GEPO = dyn_cast<GEPOperator>(C))
471  NewSrcTy = TypeMapper->remapType(GEPO->getSourceElementType());
472 
473  if (ConstantExpr *CE = dyn_cast<ConstantExpr>(C))
474  return getVM()[V] = CE->getWithOperands(Ops, NewTy, false, NewSrcTy);
475  if (isa<ConstantArray>(C))
476  return getVM()[V] = ConstantArray::get(cast<ArrayType>(NewTy), Ops);
477  if (isa<ConstantStruct>(C))
478  return getVM()[V] = ConstantStruct::get(cast<StructType>(NewTy), Ops);
479  if (isa<ConstantVector>(C))
480  return getVM()[V] = ConstantVector::get(Ops);
481  // If this is a no-operand constant, it must be because the type was remapped.
482  if (isa<UndefValue>(C))
483  return getVM()[V] = UndefValue::get(NewTy);
484  if (isa<ConstantAggregateZero>(C))
485  return getVM()[V] = ConstantAggregateZero::get(NewTy);
486  assert(isa<ConstantPointerNull>(C));
487  return getVM()[V] = ConstantPointerNull::get(cast<PointerType>(NewTy));
488 }
489 
490 Value *Mapper::mapBlockAddress(const BlockAddress &BA) {
491  Function *F = cast<Function>(mapValue(BA.getFunction()));
492 
493  // F may not have materialized its initializer. In that case, create a
494  // dummy basic block for now, and replace it once we've materialized all
495  // the initializers.
496  BasicBlock *BB;
497  if (F->empty()) {
498  DelayedBBs.push_back(DelayedBasicBlock(BA));
499  BB = DelayedBBs.back().TempBB.get();
500  } else {
501  BB = cast_or_null<BasicBlock>(mapValue(BA.getBasicBlock()));
502  }
503 
504  return getVM()[&BA] = BlockAddress::get(F, BB ? BB : BA.getBasicBlock());
505 }
506 
507 Metadata *Mapper::mapToMetadata(const Metadata *Key, Metadata *Val) {
508  getVM().MD()[Key].reset(Val);
509  return Val;
510 }
511 
512 Metadata *Mapper::mapToSelf(const Metadata *MD) {
513  return mapToMetadata(MD, const_cast<Metadata *>(MD));
514 }
515 
516 Optional<Metadata *> MDNodeMapper::tryToMapOperand(const Metadata *Op) {
517  if (!Op)
518  return nullptr;
519 
520  if (Optional<Metadata *> MappedOp = M.mapSimpleMetadata(Op)) {
521 #ifndef NDEBUG
522  if (auto *CMD = dyn_cast<ConstantAsMetadata>(Op))
523  assert((!*MappedOp || M.getVM().count(CMD->getValue()) ||
524  M.getVM().getMappedMD(Op)) &&
525  "Expected Value to be memoized");
526  else
527  assert((isa<MDString>(Op) || M.getVM().getMappedMD(Op)) &&
528  "Expected result to be memoized");
529 #endif
530  return *MappedOp;
531  }
532 
533  const MDNode &N = *cast<MDNode>(Op);
534  if (N.isDistinct())
535  return mapDistinctNode(N);
536  return None;
537 }
538 
539 static Metadata *cloneOrBuildODR(const MDNode &N) {
540  auto *CT = dyn_cast<DICompositeType>(&N);
541  // If ODR type uniquing is enabled, we would have uniqued composite types
542  // with identifiers during bitcode reading, so we can just use CT.
543  if (CT && CT->getContext().isODRUniquingDebugTypes() &&
544  CT->getIdentifier() != "")
545  return const_cast<DICompositeType *>(CT);
547 }
548 
549 MDNode *MDNodeMapper::mapDistinctNode(const MDNode &N) {
550  assert(N.isDistinct() && "Expected a distinct node");
551  assert(!M.getVM().getMappedMD(&N) && "Expected an unmapped node");
552  DistinctWorklist.push_back(
553  cast<MDNode>((M.Flags & RF_MoveDistinctMDs)
554  ? M.mapToSelf(&N)
555  : M.mapToMetadata(&N, cloneOrBuildODR(N))));
556  return DistinctWorklist.back();
557 }
558 
560  Value *MappedV) {
561  if (CMD.getValue() == MappedV)
562  return const_cast<ConstantAsMetadata *>(&CMD);
563  return MappedV ? ConstantAsMetadata::getConstant(MappedV) : nullptr;
564 }
565 
567  if (!Op)
568  return nullptr;
569 
570  if (Optional<Metadata *> MappedOp = M.getVM().getMappedMD(Op))
571  return *MappedOp;
572 
573  if (isa<MDString>(Op))
574  return const_cast<Metadata *>(Op);
575 
576  if (auto *CMD = dyn_cast<ConstantAsMetadata>(Op))
577  return wrapConstantAsMetadata(*CMD, M.getVM().lookup(CMD->getValue()));
578 
579  return None;
580 }
581 
582 Metadata &MDNodeMapper::UniquedGraph::getFwdReference(MDNode &Op) {
583  auto Where = Info.find(&Op);
584  assert(Where != Info.end() && "Expected a valid reference");
585 
586  auto &OpD = Where->second;
587  if (!OpD.HasChanged)
588  return Op;
589 
590  // Lazily construct a temporary node.
591  if (!OpD.Placeholder)
592  OpD.Placeholder = Op.clone();
593 
594  return *OpD.Placeholder;
595 }
596 
597 template <class OperandMapper>
598 void MDNodeMapper::remapOperands(MDNode &N, OperandMapper mapOperand) {
599  assert(!N.isUniqued() && "Expected distinct or temporary nodes");
600  for (unsigned I = 0, E = N.getNumOperands(); I != E; ++I) {
601  Metadata *Old = N.getOperand(I);
602  Metadata *New = mapOperand(Old);
603 
604  if (Old != New)
605  N.replaceOperandWith(I, New);
606  }
607 }
608 
609 namespace {
610 
611 /// An entry in the worklist for the post-order traversal.
612 struct POTWorklistEntry {
613  MDNode *N; ///< Current node.
614  MDNode::op_iterator Op; ///< Current operand of \c N.
615 
616  /// Keep a flag of whether operands have changed in the worklist to avoid
617  /// hitting the map in \a UniquedGraph.
618  bool HasChanged = false;
619 
620  POTWorklistEntry(MDNode &N) : N(&N), Op(N.op_begin()) {}
621 };
622 
623 } // end anonymous namespace
624 
625 bool MDNodeMapper::createPOT(UniquedGraph &G, const MDNode &FirstN) {
626  assert(G.Info.empty() && "Expected a fresh traversal");
627  assert(FirstN.isUniqued() && "Expected uniqued node in POT");
628 
629  // Construct a post-order traversal of the uniqued subgraph under FirstN.
630  bool AnyChanges = false;
632  Worklist.push_back(POTWorklistEntry(const_cast<MDNode &>(FirstN)));
633  (void)G.Info[&FirstN];
634  while (!Worklist.empty()) {
635  // Start or continue the traversal through the this node's operands.
636  auto &WE = Worklist.back();
637  if (MDNode *N = visitOperands(G, WE.Op, WE.N->op_end(), WE.HasChanged)) {
638  // Push a new node to traverse first.
639  Worklist.push_back(POTWorklistEntry(*N));
640  continue;
641  }
642 
643  // Push the node onto the POT.
644  assert(WE.N->isUniqued() && "Expected only uniqued nodes");
645  assert(WE.Op == WE.N->op_end() && "Expected to visit all operands");
646  auto &D = G.Info[WE.N];
647  AnyChanges |= D.HasChanged = WE.HasChanged;
648  D.ID = G.POT.size();
649  G.POT.push_back(WE.N);
650 
651  // Pop the node off the worklist.
652  Worklist.pop_back();
653  }
654  return AnyChanges;
655 }
656 
657 MDNode *MDNodeMapper::visitOperands(UniquedGraph &G, MDNode::op_iterator &I,
658  MDNode::op_iterator E, bool &HasChanged) {
659  while (I != E) {
660  Metadata *Op = *I++; // Increment even on early return.
661  if (Optional<Metadata *> MappedOp = tryToMapOperand(Op)) {
662  // Check if the operand changes.
663  HasChanged |= Op != *MappedOp;
664  continue;
665  }
666 
667  // A uniqued metadata node.
668  MDNode &OpN = *cast<MDNode>(Op);
669  assert(OpN.isUniqued() &&
670  "Only uniqued operands cannot be mapped immediately");
671  if (G.Info.insert(std::make_pair(&OpN, Data())).second)
672  return &OpN; // This is a new one. Return it.
673  }
674  return nullptr;
675 }
676 
677 void MDNodeMapper::UniquedGraph::propagateChanges() {
678  bool AnyChanges;
679  do {
680  AnyChanges = false;
681  for (MDNode *N : POT) {
682  auto &D = Info[N];
683  if (D.HasChanged)
684  continue;
685 
686  if (llvm::none_of(N->operands(), [&](const Metadata *Op) {
687  auto Where = Info.find(Op);
688  return Where != Info.end() && Where->second.HasChanged;
689  }))
690  continue;
691 
692  AnyChanges = D.HasChanged = true;
693  }
694  } while (AnyChanges);
695 }
696 
697 void MDNodeMapper::mapNodesInPOT(UniquedGraph &G) {
698  // Construct uniqued nodes, building forward references as necessary.
699  SmallVector<MDNode *, 16> CyclicNodes;
700  for (auto *N : G.POT) {
701  auto &D = G.Info[N];
702  if (!D.HasChanged) {
703  // The node hasn't changed.
704  M.mapToSelf(N);
705  continue;
706  }
707 
708  // Remember whether this node had a placeholder.
709  bool HadPlaceholder(D.Placeholder);
710 
711  // Clone the uniqued node and remap the operands.
712  TempMDNode ClonedN = D.Placeholder ? std::move(D.Placeholder) : N->clone();
713  remapOperands(*ClonedN, [this, &D, &G](Metadata *Old) {
714  if (Optional<Metadata *> MappedOp = getMappedOp(Old))
715  return *MappedOp;
716  (void)D;
717  assert(G.Info[Old].ID > D.ID && "Expected a forward reference");
718  return &G.getFwdReference(*cast<MDNode>(Old));
719  });
720 
721  auto *NewN = MDNode::replaceWithUniqued(std::move(ClonedN));
722  M.mapToMetadata(N, NewN);
723 
724  // Nodes that were referenced out of order in the POT are involved in a
725  // uniquing cycle.
726  if (HadPlaceholder)
727  CyclicNodes.push_back(NewN);
728  }
729 
730  // Resolve cycles.
731  for (auto *N : CyclicNodes)
732  if (!N->isResolved())
733  N->resolveCycles();
734 }
735 
736 Metadata *MDNodeMapper::map(const MDNode &N) {
737  assert(DistinctWorklist.empty() && "MDNodeMapper::map is not recursive");
738  assert(!(M.Flags & RF_NoModuleLevelChanges) &&
739  "MDNodeMapper::map assumes module-level changes");
740 
741  // Require resolved nodes whenever metadata might be remapped.
742  assert(N.isResolved() && "Unexpected unresolved node");
743 
744  Metadata *MappedN =
745  N.isUniqued() ? mapTopLevelUniquedNode(N) : mapDistinctNode(N);
746  while (!DistinctWorklist.empty())
747  remapOperands(*DistinctWorklist.pop_back_val(), [this](Metadata *Old) {
748  if (Optional<Metadata *> MappedOp = tryToMapOperand(Old))
749  return *MappedOp;
750  return mapTopLevelUniquedNode(*cast<MDNode>(Old));
751  });
752  return MappedN;
753 }
754 
755 Metadata *MDNodeMapper::mapTopLevelUniquedNode(const MDNode &FirstN) {
756  assert(FirstN.isUniqued() && "Expected uniqued node");
757 
758  // Create a post-order traversal of uniqued nodes under FirstN.
759  UniquedGraph G;
760  if (!createPOT(G, FirstN)) {
761  // Return early if no nodes have changed.
762  for (const MDNode *N : G.POT)
763  M.mapToSelf(N);
764  return &const_cast<MDNode &>(FirstN);
765  }
766 
767  // Update graph with all nodes that have changed.
768  G.propagateChanges();
769 
770  // Map all the nodes in the graph.
771  mapNodesInPOT(G);
772 
773  // Return the original node, remapped.
774  return *getMappedOp(&FirstN);
775 }
776 
777 namespace {
778 
779 struct MapMetadataDisabler {
780  ValueToValueMapTy &VM;
781 
782  MapMetadataDisabler(ValueToValueMapTy &VM) : VM(VM) {
783  VM.disableMapMetadata();
784  }
785 
786  ~MapMetadataDisabler() { VM.enableMapMetadata(); }
787 };
788 
789 } // end anonymous namespace
790 
791 Optional<Metadata *> Mapper::mapSimpleMetadata(const Metadata *MD) {
792  // If the value already exists in the map, use it.
793  if (Optional<Metadata *> NewMD = getVM().getMappedMD(MD))
794  return *NewMD;
795 
796  if (isa<MDString>(MD))
797  return const_cast<Metadata *>(MD);
798 
799  // This is a module-level metadata. If nothing at the module level is
800  // changing, use an identity mapping.
801  if ((Flags & RF_NoModuleLevelChanges))
802  return const_cast<Metadata *>(MD);
803 
804  if (auto *CMD = dyn_cast<ConstantAsMetadata>(MD)) {
805  // Disallow recursion into metadata mapping through mapValue.
806  MapMetadataDisabler MMD(getVM());
807 
808  // Don't memoize ConstantAsMetadata. Instead of lasting until the
809  // LLVMContext is destroyed, they can be deleted when the GlobalValue they
810  // reference is destructed. These aren't super common, so the extra
811  // indirection isn't that expensive.
812  return wrapConstantAsMetadata(*CMD, mapValue(CMD->getValue()));
813  }
814 
815  assert(isa<MDNode>(MD) && "Expected a metadata node");
816 
817  return None;
818 }
819 
820 Metadata *Mapper::mapMetadata(const Metadata *MD) {
821  assert(MD && "Expected valid metadata");
822  assert(!isa<LocalAsMetadata>(MD) && "Unexpected local metadata");
823 
824  if (Optional<Metadata *> NewMD = mapSimpleMetadata(MD))
825  return *NewMD;
826 
827  return MDNodeMapper(*this).map(*cast<MDNode>(MD));
828 }
829 
830 void Mapper::flush() {
831  // Flush out the worklist of global values.
832  while (!Worklist.empty()) {
833  WorklistEntry E = Worklist.pop_back_val();
834  CurrentMCID = E.MCID;
835  switch (E.Kind) {
836  case WorklistEntry::MapGlobalInit:
837  E.Data.GVInit.GV->setInitializer(mapConstant(E.Data.GVInit.Init));
838  remapGlobalObjectMetadata(*E.Data.GVInit.GV);
839  break;
840  case WorklistEntry::MapAppendingVar: {
841  unsigned PrefixSize = AppendingInits.size() - E.AppendingGVNumNewMembers;
842  mapAppendingVariable(*E.Data.AppendingGV.GV,
843  E.Data.AppendingGV.InitPrefix,
844  E.AppendingGVIsOldCtorDtor,
845  makeArrayRef(AppendingInits).slice(PrefixSize));
846  AppendingInits.resize(PrefixSize);
847  break;
848  }
849  case WorklistEntry::MapGlobalAliasee:
850  E.Data.GlobalAliasee.GA->setAliasee(
851  mapConstant(E.Data.GlobalAliasee.Aliasee));
852  break;
854  remapFunction(*E.Data.RemapF);
855  break;
856  }
857  }
858  CurrentMCID = 0;
859 
860  // Finish logic for block addresses now that all global values have been
861  // handled.
862  while (!DelayedBBs.empty()) {
863  DelayedBasicBlock DBB = DelayedBBs.pop_back_val();
864  BasicBlock *BB = cast_or_null<BasicBlock>(mapValue(DBB.OldBB));
865  DBB.TempBB->replaceAllUsesWith(BB ? BB : DBB.OldBB);
866  }
867 }
868 
870  // Remap operands.
871  for (Use &Op : I->operands()) {
872  Value *V = mapValue(Op);
873  // If we aren't ignoring missing entries, assert that something happened.
874  if (V)
875  Op = V;
876  else
877  assert((Flags & RF_IgnoreMissingLocals) &&
878  "Referenced value not in value map!");
879  }
880 
881  // Remap phi nodes' incoming blocks.
882  if (PHINode *PN = dyn_cast<PHINode>(I)) {
883  for (unsigned i = 0, e = PN->getNumIncomingValues(); i != e; ++i) {
884  Value *V = mapValue(PN->getIncomingBlock(i));
885  // If we aren't ignoring missing entries, assert that something happened.
886  if (V)
887  PN->setIncomingBlock(i, cast<BasicBlock>(V));
888  else
889  assert((Flags & RF_IgnoreMissingLocals) &&
890  "Referenced block not in value map!");
891  }
892  }
893 
894  // Remap attached metadata.
896  I->getAllMetadata(MDs);
897  for (const auto &MI : MDs) {
898  MDNode *Old = MI.second;
899  MDNode *New = cast_or_null<MDNode>(mapMetadata(Old));
900  if (New != Old)
901  I->setMetadata(MI.first, New);
902  }
903 
904  if (!TypeMapper)
905  return;
906 
907  // If the instruction's type is being remapped, do so now.
908  if (auto CS = CallSite(I)) {
910  FunctionType *FTy = CS.getFunctionType();
911  Tys.reserve(FTy->getNumParams());
912  for (Type *Ty : FTy->params())
913  Tys.push_back(TypeMapper->remapType(Ty));
914  CS.mutateFunctionType(FunctionType::get(
915  TypeMapper->remapType(I->getType()), Tys, FTy->isVarArg()));
916 
917  LLVMContext &C = CS->getContext();
918  AttributeList Attrs = CS.getAttributes();
919  for (unsigned i = 0; i < Attrs.getNumAttrSets(); ++i) {
920  if (Attrs.hasAttribute(i, Attribute::ByVal)) {
921  Type *Ty = Attrs.getAttribute(i, Attribute::ByVal).getValueAsType();
922  if (!Ty)
923  continue;
924 
925  Attrs = Attrs.removeAttribute(C, i, Attribute::ByVal);
926  Attrs = Attrs.addAttribute(
927  C, i, Attribute::getWithByValType(C, TypeMapper->remapType(Ty)));
928  }
929  }
930  CS.setAttributes(Attrs);
931  return;
932  }
933  if (auto *AI = dyn_cast<AllocaInst>(I))
934  AI->setAllocatedType(TypeMapper->remapType(AI->getAllocatedType()));
935  if (auto *GEP = dyn_cast<GetElementPtrInst>(I)) {
936  GEP->setSourceElementType(
937  TypeMapper->remapType(GEP->getSourceElementType()));
938  GEP->setResultElementType(
939  TypeMapper->remapType(GEP->getResultElementType()));
940  }
941  I->mutateType(TypeMapper->remapType(I->getType()));
942 }
943 
944 void Mapper::remapGlobalObjectMetadata(GlobalObject &GO) {
946  GO.getAllMetadata(MDs);
947  GO.clearMetadata();
948  for (const auto &I : MDs)
949  GO.addMetadata(I.first, *cast<MDNode>(mapMetadata(I.second)));
950 }
951 
952 void Mapper::remapFunction(Function &F) {
953  // Remap the operands.
954  for (Use &Op : F.operands())
955  if (Op)
956  Op = mapValue(Op);
957 
958  // Remap the metadata attachments.
959  remapGlobalObjectMetadata(F);
960 
961  // Remap the argument types.
962  if (TypeMapper)
963  for (Argument &A : F.args())
964  A.mutateType(TypeMapper->remapType(A.getType()));
965 
966  // Remap the instructions.
967  for (BasicBlock &BB : F)
968  for (Instruction &I : BB)
969  remapInstruction(&I);
970 }
971 
972 void Mapper::mapAppendingVariable(GlobalVariable &GV, Constant *InitPrefix,
973  bool IsOldCtorDtor,
974  ArrayRef<Constant *> NewMembers) {
976  if (InitPrefix) {
977  unsigned NumElements =
978  cast<ArrayType>(InitPrefix->getType())->getNumElements();
979  for (unsigned I = 0; I != NumElements; ++I)
980  Elements.push_back(InitPrefix->getAggregateElement(I));
981  }
982 
983  PointerType *VoidPtrTy;
984  Type *EltTy;
985  if (IsOldCtorDtor) {
986  // FIXME: This upgrade is done during linking to support the C API. See
987  // also IRLinker::linkAppendingVarProto() in IRMover.cpp.
988  VoidPtrTy = Type::getInt8Ty(GV.getContext())->getPointerTo();
989  auto &ST = *cast<StructType>(NewMembers.front()->getType());
990  Type *Tys[3] = {ST.getElementType(0), ST.getElementType(1), VoidPtrTy};
991  EltTy = StructType::get(GV.getContext(), Tys, false);
992  }
993 
994  for (auto *V : NewMembers) {
995  Constant *NewV;
996  if (IsOldCtorDtor) {
997  auto *S = cast<ConstantStruct>(V);
998  auto *E1 = cast<Constant>(mapValue(S->getOperand(0)));
999  auto *E2 = cast<Constant>(mapValue(S->getOperand(1)));
1000  Constant *Null = Constant::getNullValue(VoidPtrTy);
1001  NewV = ConstantStruct::get(cast<StructType>(EltTy), E1, E2, Null);
1002  } else {
1003  NewV = cast_or_null<Constant>(mapValue(V));
1004  }
1005  Elements.push_back(NewV);
1006  }
1007 
1009  cast<ArrayType>(GV.getType()->getElementType()), Elements));
1010 }
1011 
1012 void Mapper::scheduleMapGlobalInitializer(GlobalVariable &GV, Constant &Init,
1013  unsigned MCID) {
1014  assert(AlreadyScheduled.insert(&GV).second && "Should not reschedule");
1015  assert(MCID < MCs.size() && "Invalid mapping context");
1016 
1017  WorklistEntry WE;
1018  WE.Kind = WorklistEntry::MapGlobalInit;
1019  WE.MCID = MCID;
1020  WE.Data.GVInit.GV = &GV;
1021  WE.Data.GVInit.Init = &Init;
1022  Worklist.push_back(WE);
1023 }
1024 
1025 void Mapper::scheduleMapAppendingVariable(GlobalVariable &GV,
1026  Constant *InitPrefix,
1027  bool IsOldCtorDtor,
1028  ArrayRef<Constant *> NewMembers,
1029  unsigned MCID) {
1030  assert(AlreadyScheduled.insert(&GV).second && "Should not reschedule");
1031  assert(MCID < MCs.size() && "Invalid mapping context");
1032 
1033  WorklistEntry WE;
1034  WE.Kind = WorklistEntry::MapAppendingVar;
1035  WE.MCID = MCID;
1036  WE.Data.AppendingGV.GV = &GV;
1037  WE.Data.AppendingGV.InitPrefix = InitPrefix;
1038  WE.AppendingGVIsOldCtorDtor = IsOldCtorDtor;
1039  WE.AppendingGVNumNewMembers = NewMembers.size();
1040  Worklist.push_back(WE);
1041  AppendingInits.append(NewMembers.begin(), NewMembers.end());
1042 }
1043 
1044 void Mapper::scheduleMapGlobalAliasee(GlobalAlias &GA, Constant &Aliasee,
1045  unsigned MCID) {
1046  assert(AlreadyScheduled.insert(&GA).second && "Should not reschedule");
1047  assert(MCID < MCs.size() && "Invalid mapping context");
1048 
1049  WorklistEntry WE;
1050  WE.Kind = WorklistEntry::MapGlobalAliasee;
1051  WE.MCID = MCID;
1052  WE.Data.GlobalAliasee.GA = &GA;
1053  WE.Data.GlobalAliasee.Aliasee = &Aliasee;
1054  Worklist.push_back(WE);
1055 }
1056 
1057 void Mapper::scheduleRemapFunction(Function &F, unsigned MCID) {
1058  assert(AlreadyScheduled.insert(&F).second && "Should not reschedule");
1059  assert(MCID < MCs.size() && "Invalid mapping context");
1060 
1061  WorklistEntry WE;
1062  WE.Kind = WorklistEntry::RemapFunction;
1063  WE.MCID = MCID;
1064  WE.Data.RemapF = &F;
1065  Worklist.push_back(WE);
1066 }
1067 
1068 void Mapper::addFlags(RemapFlags Flags) {
1069  assert(!hasWorkToDo() && "Expected to have flushed the worklist");
1070  this->Flags = this->Flags | Flags;
1071 }
1072 
1073 static Mapper *getAsMapper(void *pImpl) {
1074  return reinterpret_cast<Mapper *>(pImpl);
1075 }
1076 
1077 namespace {
1078 
1079 class FlushingMapper {
1080  Mapper &M;
1081 
1082 public:
1083  explicit FlushingMapper(void *pImpl) : M(*getAsMapper(pImpl)) {
1084  assert(!M.hasWorkToDo() && "Expected to be flushed");
1085  }
1086 
1087  ~FlushingMapper() { M.flush(); }
1088 
1089  Mapper *operator->() const { return &M; }
1090 };
1091 
1092 } // end anonymous namespace
1093 
1095  ValueMapTypeRemapper *TypeMapper,
1096  ValueMaterializer *Materializer)
1097  : pImpl(new Mapper(VM, Flags, TypeMapper, Materializer)) {}
1098 
1100 
1101 unsigned
1103  ValueMaterializer *Materializer) {
1104  return getAsMapper(pImpl)->registerAlternateMappingContext(VM, Materializer);
1105 }
1106 
1108  FlushingMapper(pImpl)->addFlags(Flags);
1109 }
1110 
1112  return FlushingMapper(pImpl)->mapValue(&V);
1113 }
1114 
1116  return cast_or_null<Constant>(mapValue(C));
1117 }
1118 
1120  return FlushingMapper(pImpl)->mapMetadata(&MD);
1121 }
1122 
1124  return cast_or_null<MDNode>(mapMetadata(N));
1125 }
1126 
1128  FlushingMapper(pImpl)->remapInstruction(&I);
1129 }
1130 
1132  FlushingMapper(pImpl)->remapFunction(F);
1133 }
1134 
1136  Constant &Init,
1137  unsigned MCID) {
1138  getAsMapper(pImpl)->scheduleMapGlobalInitializer(GV, Init, MCID);
1139 }
1140 
1142  Constant *InitPrefix,
1143  bool IsOldCtorDtor,
1144  ArrayRef<Constant *> NewMembers,
1145  unsigned MCID) {
1146  getAsMapper(pImpl)->scheduleMapAppendingVariable(
1147  GV, InitPrefix, IsOldCtorDtor, NewMembers, MCID);
1148 }
1149 
1151  unsigned MCID) {
1152  getAsMapper(pImpl)->scheduleMapGlobalAliasee(GA, Aliasee, MCID);
1153 }
1154 
1156  getAsMapper(pImpl)->scheduleRemapFunction(F, MCID);
1157 }
const T & front() const
front - Get the first element.
Definition: ArrayRef.h:151
static unsigned getMappedOp(unsigned PseudoOp)
uint64_t CallInst * C
const_iterator end(StringRef path)
Get end iterator over path.
Definition: Path.cpp:233
bool isUniqued() const
Definition: Metadata.h:941
Tracking metadata reference owned by Metadata.
Definition: Metadata.h:710
static MDTuple * get(LLVMContext &Context, ArrayRef< Metadata *> MDs)
Definition: Metadata.h:1132
bool empty() const
Definition: Function.h:686
bool isDistinct() const
Definition: Metadata.h:942
GCNRegPressure max(const GCNRegPressure &P1, const GCNRegPressure &P2)
This class represents an incoming formal argument to a Function.
Definition: Argument.h:29
This class represents lattice values for constants.
Definition: AllocatorList.h:23
iterator begin() const
Definition: ArrayRef.h:136
void replaceOperandWith(unsigned I, Metadata *New)
Replace a specific operand.
Definition: Metadata.cpp:858
void RemapFunction(Function &F, ValueToValueMapTy &VM, RemapFlags Flags=RF_None, ValueMapTypeRemapper *TypeMapper=nullptr, ValueMaterializer *Materializer=nullptr)
Remap the operands, metadata, arguments, and instructions of a function.
Definition: ValueMapper.h:263
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
static ConstantAggregateZero * get(Type *Ty)
Definition: Constants.cpp:1341
This file contains the declarations for metadata subclasses.
LLVMContext & getContext() const
All values hold a context through their type.
Definition: Value.cpp:732
Metadata node.
Definition: Metadata.h:863
F(f)
void scheduleRemapFunction(Function &F, unsigned MappingContextID=0)
const MDOperand & getOperand(unsigned I) const
Definition: Metadata.h:1068
Hexagon Common GEP
void getAllMetadata(SmallVectorImpl< std::pair< unsigned, MDNode *>> &MDs) const
Appends all attachments for the global to MDs, sorting by attachment ID.
Definition: Metadata.cpp:1413
void reserve(size_type N)
Definition: SmallVector.h:369
static Mapper * getAsMapper(void *pImpl)
bool hasAttribute(unsigned Index, Attribute::AttrKind Kind) const
Return true if the attribute exists at the given index.
static Constant * get(ArrayType *T, ArrayRef< Constant *> V)
Definition: Constants.cpp:992
TempMDNode clone() const
Create a (temporary) clone of this.
Definition: Metadata.cpp:521
static Constant * getNullValue(Type *Ty)
Constructor to create a &#39;0&#39; constant of arbitrary type.
Definition: Constants.cpp:274
static std::enable_if< std::is_base_of< MDNode, T >::value, T * >::type replaceWithDistinct(std::unique_ptr< T, TempMDNodeDeleter > N)
Replace a temporary node with a distinct one.
Definition: Metadata.h:993
Function * getFunction() const
Definition: Constants.h:865
The address of a basic block.
Definition: Constants.h:839
ArrayRef< T > makeArrayRef(const T &OneElt)
Construct an ArrayRef from a single element.
Definition: ArrayRef.h:450
void setInitializer(Constant *InitVal)
setInitializer - Sets the initializer for this global variable, removing any existing initializer if ...
Definition: Globals.cpp:384
bool isResolved() const
Check if node is fully resolved.
Definition: Metadata.h:939
void remapInstruction(Instruction &I)
A Use represents the edge between a Value definition and its users.
Definition: Use.h:55
Constant * mapConstant(const Constant &C)
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:1206
Windows NT (Windows on ARM)
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:341
void resolveCycles()
Resolve cycles.
Definition: Metadata.cpp:620
op_iterator op_begin() const
Definition: Metadata.h:1058
Key
PAL metadata keys.
A constant value that is initialized with an expression using other constant values.
Definition: Constants.h:888
Class to represent function types.
Definition: DerivedTypes.h:103
Metadata * mapMetadata(const Metadata &MD)
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:244
op_range operands() const
Definition: Metadata.h:1066
Type * getValueAsType() const
Return the attribute&#39;s value as a Type.
Definition: Attributes.cpp:230
bool isVarArg() const
Definition: DerivedTypes.h:123
ArrayRef - Represent a constant reference to an array (0 or more elements consecutively in memory)...
Definition: APInt.h:32
BasicBlock * getBasicBlock() const
Definition: Constants.h:866
void enableMapMetadata()
Definition: ValueMap.h:124
constexpr char Attrs[]
Key for Kernel::Metadata::mAttrs.
If this flag is set, the remapper knows that only local values within a function (such as an instruct...
Definition: ValueMapper.h:72
Analysis containing CSE Info
Definition: CSEInfo.cpp:20
Class to represent pointers.
Definition: DerivedTypes.h:544
void remapInstruction(Instruction *I, ValueToValueMapTy &VMap)
Convert the instruction operands from referencing the current values into those specified by VMap...
Definition: LoopUnroll.cpp:67
Constant * getAggregateElement(unsigned Elt) const
For aggregates (struct/array/vector) return the constant that corresponds to the specified element if...
Definition: Constants.cpp:344
static MetadataAsValue * get(LLVMContext &Context, Metadata *MD)
Definition: Metadata.cpp:105
static Metadata * cloneOrBuildODR(const MDNode &N)
This is a class that can be implemented by clients to materialize Values on demand.
Definition: ValueMapper.h:50
static std::enable_if< std::is_base_of< MDNode, T >::value, T * >::type replaceWithUniqued(std::unique_ptr< T, TempMDNodeDeleter > N)
Replace a temporary node with a uniqued one.
Definition: Metadata.h:983
static ConstantPointerNull * get(PointerType *T)
Static factory methods - Return objects of the specified value.
Definition: Constants.cpp:1410
LLVM Basic Block Representation.
Definition: BasicBlock.h:57
The instances of the Type class are immutable: once they are created, they are never changed...
Definition: Type.h:45
This is an important class for using LLVM in a threaded context.
Definition: LLVMContext.h:64
static ConstantAsMetadata * wrapConstantAsMetadata(const ConstantAsMetadata &CMD, Value *MappedV)
static BlockAddress * get(Function *F, BasicBlock *BB)
Return a BlockAddress for the specified function and basic block.
Definition: Constants.cpp:1443
size_t size() const
size - Get the array size.
Definition: ArrayRef.h:148
static GCRegistry::Add< CoreCLRGC > E("coreclr", "CoreCLR-compatible GC")
This is an important base class in LLVM.
Definition: Constant.h:41
This file contains the declarations for the subclasses of Constant, which represent the different fla...
unsigned getNumParams() const
Return the number of fixed parameters this function type requires.
Definition: DerivedTypes.h:139
ArrayRef< Type * > params() const
Definition: DerivedTypes.h:130
void scheduleMapGlobalInitializer(GlobalVariable &GV, Constant &Init, unsigned MappingContextID=0)
static FunctionType * get(Type *Result, ArrayRef< Type *> Params, bool isVarArg)
This static method is the primary way of constructing a FunctionType.
Definition: Type.cpp:296
static Constant * get(StructType *T, ArrayRef< Constant *> V)
Definition: Constants.cpp:1053
static Attribute getWithByValType(LLVMContext &Context, Type *Ty)
Definition: Attributes.cpp:170
op_range operands()
Definition: User.h:237
void disableMapMetadata()
Definition: ValueMap.h:125
static UndefValue * get(Type *T)
Static factory methods - Return an &#39;undef&#39; object of the specified type.
Definition: Constants.cpp:1424
RemapFlags
These are flags that the value mapping APIs allow.
Definition: ValueMapper.h:66
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
void setMetadata(unsigned KindID, MDNode *Node)
Set the metadata of the specified kind to the specified node.
Definition: Metadata.cpp:1222
static ConstantAsMetadata * getConstant(Value *C)
Definition: Metadata.h:360
static ValueAsMetadata * get(Value *V)
Definition: Metadata.cpp:348
Constant * getValue() const
Definition: Metadata.h:417
This is a &#39;vector&#39; (really, a variable-sized array), optimized for the case when the array is small...
Definition: SmallVector.h:837
void addMetadata(unsigned KindID, MDNode &MD)
Add a metadata attachment.
Definition: Metadata.cpp:1390
iterator end() const
Definition: ArrayRef.h:137
const DataFlowGraph & G
Definition: RDFGraph.cpp:202
LLVM_NODISCARD T pop_back_val()
Definition: SmallVector.h:374
static GCRegistry::Add< StatepointGC > D("statepoint-example", "an example strategy for statepoint")
void remapFunction(Function &F)
void scheduleMapGlobalAliasee(GlobalAlias &GA, Constant &Aliasee, unsigned MappingContextID=0)
void getAllMetadata(SmallVectorImpl< std::pair< unsigned, MDNode *>> &MDs) const
Get all metadata attached to this Instruction.
Definition: Instruction.h:250
unsigned getNumAttrSets() const
ValueMapper(ValueToValueMapTy &VM, RemapFlags Flags=RF_None, ValueMapTypeRemapper *TypeMapper=nullptr, ValueMaterializer *Materializer=nullptr)
void append(in_iter in_start, in_iter in_end)
Add the specified range to the end of the SmallVector.
Definition: SmallVector.h:387
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
LLVM_NODISCARD AttributeList addAttribute(LLVMContext &C, unsigned Index, Attribute::AttrKind Kind) const
Add an attribute to the attribute set at the given index.
LLVM_NODISCARD bool empty() const
Definition: SmallVector.h:55
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
#define N
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
void addFlags(RemapFlags Flags)
Add to the current RemapFlags.
static InlineAsm * get(FunctionType *Ty, StringRef AsmString, StringRef Constraints, bool hasSideEffects, bool isAlignStack=false, AsmDialect asmDialect=AD_ATT)
InlineAsm::get - Return the specified uniqued inline asm string.
Definition: InlineAsm.cpp:42
void mutateType(Type *Ty)
Mutate the type of this Value to be of the specified type.
Definition: Value.h:643
Value * mapValue(const Value &V)
assert(ImpDefSCC.getReg()==AMDGPU::SCC &&ImpDefSCC.isDef())
LLVM Value Representation.
Definition: Value.h:72
unsigned registerAlternateMappingContext(ValueToValueMapTy &VM, ValueMaterializer *Materializer=nullptr)
Register an alternate mapping context.
void scheduleMapAppendingVariable(GlobalVariable &GV, Constant *InitPrefix, bool IsOldCtorDtor, ArrayRef< Constant *> NewMembers, unsigned MappingContextID=0)
virtual Type * remapType(Type *SrcTy)=0
The client should implement this method if they want to remap types while mapping values...
IRTranslator LLVM IR MI
unsigned getNumOperands() const
Return number of MDNode operands.
Definition: Metadata.h:1074
Root of the metadata hierarchy.
Definition: Metadata.h:57
static IntegerType * getInt8Ty(LLVMContext &C)
Definition: Type.cpp:173
static Constant * get(ArrayRef< Constant *> V)
Definition: Constants.cpp:1088
Type * getElementType() const
Definition: DerivedTypes.h:563
PointerType * getType() const
Global values are always pointers.
Definition: GlobalValue.h:277
iterator_range< arg_iterator > args()
Definition: Function.h:713
MDNode * mapMDNode(const MDNode &N)
void resize(size_type N)
Definition: SmallVector.h:344