Subversion Repositories QNX 8.QNX8 LLVM/Clang compiler suite

Rev

Blame | Last modification | View Log | Download | RSS feed

  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; };
  51. DEFINE_SYMBOL_TABLE_PARENT_TYPE(Instruction, BasicBlock)
  52. DEFINE_SYMBOL_TABLE_PARENT_TYPE(BasicBlock, Function)
  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> {
  67.   using ListTy = SymbolTableList<ValueSubClass>;
  68.   using iterator = typename simple_ilist<ValueSubClass>::iterator;
  69.   using ItemParentClass =
  70.       typename SymbolTableListParentType<ValueSubClass>::type;
  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 = reinterpret_cast<size_t>(
  80.         &((ItemParentClass *)nullptr->*ItemParentClass::getSublistAccess(
  81.                                            static_cast<ValueSubClass *>(
  82.                                                nullptr))));
  83.     ListTy *Anchor = static_cast<ListTy *>(this);
  84.     return reinterpret_cast<ItemParentClass*>(reinterpret_cast<char*>(Anchor)-
  85.                                               Offset);
  86.   }
  87.  
  88.   static ListTy &getList(ItemParentClass *Par) {
  89.     return Par->*(Par->getSublistAccess((ValueSubClass*)nullptr));
  90.   }
  91.  
  92.   static ValueSymbolTable *getSymTab(ItemParentClass *Par) {
  93.     return Par ? toPtr(Par->getValueSymbolTable()) : nullptr;
  94.   }
  95.  
  96. public:
  97.   void addNodeToList(ValueSubClass *V);
  98.   void removeNodeFromList(ValueSubClass *V);
  99.   void transferNodesFromList(SymbolTableListTraits &L2, iterator first,
  100.                              iterator last);
  101.   // private:
  102.   template<typename TPtr>
  103.   void setSymTabObject(TPtr *, TPtr);
  104.   static ValueSymbolTable *toPtr(ValueSymbolTable *P) { return P; }
  105.   static ValueSymbolTable *toPtr(ValueSymbolTable &R) { return &R; }
  106. };
  107.  
  108. /// List that automatically updates parent links and symbol tables.
  109. ///
  110. /// When nodes are inserted into and removed from this list, the associated
  111. /// symbol table will be automatically updated.  Similarly, parent links get
  112. /// updated automatically.
  113. template <class T>
  114. class SymbolTableList
  115.     : public iplist_impl<simple_ilist<T>, SymbolTableListTraits<T>> {};
  116.  
  117. } // end namespace llvm
  118.  
  119. #endif // LLVM_IR_SYMBOLTABLELISTTRAITS_H
  120.