LLVM  9.0.0svn
SymbolTableListTraits.h
Go to the documentation of this file.
1 //===- llvm/SymbolTableListTraits.h - Traits for iplist ---------*- C++ -*-===//
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 a generic class that is used to implement the automatic
10 // symbol table manipulation that occurs when you put (for example) a named
11 // instruction into a basic block.
12 //
13 // The way that this is implemented is by using a special traits class with the
14 // intrusive list that makes up the list of instructions in a basic block. When
15 // a new element is added to the list of instructions, the traits class is
16 // notified, allowing the symbol table to be updated.
17 //
18 // This generic class implements the traits class. It must be generic so that
19 // it can work for all uses it, which include lists of instructions, basic
20 // blocks, arguments, functions, global variables, etc...
21 //
22 //===----------------------------------------------------------------------===//
23 
24 #ifndef LLVM_IR_SYMBOLTABLELISTTRAITS_H
25 #define LLVM_IR_SYMBOLTABLELISTTRAITS_H
26 
27 #include "llvm/ADT/ilist.h"
28 #include "llvm/ADT/simple_ilist.h"
29 #include <cstddef>
30 
31 namespace llvm {
32 
33 class Argument;
34 class BasicBlock;
35 class Function;
36 class GlobalAlias;
37 class GlobalIFunc;
38 class GlobalVariable;
39 class Instruction;
40 class Module;
41 class ValueSymbolTable;
42 
43 /// Template metafunction to get the parent type for a symbol table list.
44 ///
45 /// Implementations create a typedef called \c type so that we only need a
46 /// single template parameter for the list and traits.
47 template <typename NodeTy> struct SymbolTableListParentType {};
48 
49 #define DEFINE_SYMBOL_TABLE_PARENT_TYPE(NODE, PARENT) \
50  template <> struct SymbolTableListParentType<NODE> { using type = PARENT; };
53 DEFINE_SYMBOL_TABLE_PARENT_TYPE(Argument, Function)
54 DEFINE_SYMBOL_TABLE_PARENT_TYPE(Function, Module)
55 DEFINE_SYMBOL_TABLE_PARENT_TYPE(GlobalVariable, Module)
56 DEFINE_SYMBOL_TABLE_PARENT_TYPE(GlobalAlias, Module)
57 DEFINE_SYMBOL_TABLE_PARENT_TYPE(GlobalIFunc, Module)
58 #undef DEFINE_SYMBOL_TABLE_PARENT_TYPE
59 
60 template <typename NodeTy> class SymbolTableList;
61 
62 // ValueSubClass - The type of objects that I hold, e.g. Instruction.
63 // ItemParentClass - The type of object that owns the list, e.g. BasicBlock.
64 //
65 template <typename ValueSubClass>
66 class SymbolTableListTraits : public ilist_alloc_traits<ValueSubClass> {
69  using ItemParentClass =
71 
72 public:
73  SymbolTableListTraits() = default;
74 
75 private:
76  /// getListOwner - Return the object that owns this list. If this is a list
77  /// of instructions, it returns the BasicBlock that owns them.
78  ItemParentClass *getListOwner() {
79  size_t Offset(size_t(&((ItemParentClass*)nullptr->*ItemParentClass::
80  getSublistAccess(static_cast<ValueSubClass*>(nullptr)))));
81  ListTy *Anchor(static_cast<ListTy *>(this));
82  return reinterpret_cast<ItemParentClass*>(reinterpret_cast<char*>(Anchor)-
83  Offset);
84  }
85 
86  static ListTy &getList(ItemParentClass *Par) {
87  return Par->*(Par->getSublistAccess((ValueSubClass*)nullptr));
88  }
89 
90  static ValueSymbolTable *getSymTab(ItemParentClass *Par) {
91  return Par ? toPtr(Par->getValueSymbolTable()) : nullptr;
92  }
93 
94 public:
95  void addNodeToList(ValueSubClass *V);
96  void removeNodeFromList(ValueSubClass *V);
97  void transferNodesFromList(SymbolTableListTraits &L2, iterator first,
98  iterator last);
99  // private:
100  template<typename TPtr>
101  void setSymTabObject(TPtr *, TPtr);
102  static ValueSymbolTable *toPtr(ValueSymbolTable *P) { return P; }
103  static ValueSymbolTable *toPtr(ValueSymbolTable &R) { return &R; }
104 };
105 
106 /// List that automatically updates parent links and symbol tables.
107 ///
108 /// When nodes are inserted into and removed from this list, the associated
109 /// symbol table will be automatically updated. Similarly, parent links get
110 /// updated automatically.
111 template <class T>
112 class SymbolTableList
113  : public iplist_impl<simple_ilist<T>, SymbolTableListTraits<T>> {};
114 
115 } // end namespace llvm
116 
117 #endif // LLVM_IR_SYMBOLTABLELISTTRAITS_H
This class provides a symbol table of name/value pairs.
This class represents lattice values for constants.
Definition: AllocatorList.h:23
Various leaf nodes.
Definition: ISDOpcodes.h:59
A wrapper around an intrusive list with callbacks and non-intrusive ownership.
Definition: ilist.h:166
Use delete by default for iplist and ilist.
Definition: ilist.h:40
#define P(N)
static ValueSymbolTable * toPtr(ValueSymbolTable &R)
unsigned first
Template metafunction to get the parent type for a symbol table list.
static ValueSymbolTable * toPtr(ValueSymbolTable *P)
Iterator for intrusive lists based on ilist_node.
List that automatically updates parent links and symbol tables.
static bool getSymTab(Value *V, ValueSymbolTable *&ST)
Definition: Value.cpp:164
#define DEFINE_SYMBOL_TABLE_PARENT_TYPE(NODE, PARENT)