Context.hpp

Go to the documentation of this file.

//===- Context.hpp ----------------------------------------------*- C++ -*-===//
//
//  Copyright (C) 2020 GrammaTech, Inc.
//
//  This code is licensed under the MIT license. See the LICENSE file in the
//  project root for license terms.
//
//  This project is sponsored by the Office of Naval Research, One Liberty
//  Center, 875 N. Randolph Street, Arlington, VA 22203 under contract #
//  N68335-17-C-0700.  The content of the information does not necessarily
//  reflect the position or policy of the Government and no official
//  endorsement should be inferred.
//
//===----------------------------------------------------------------------===//
#ifndef GTIRB_CONTEXT_H
#define GTIRB_CONTEXT_H
 
#include <gtirb/Allocator.hpp>
#include <gtirb/Export.hpp>
#include <boost/functional/hash.hpp>
#include <boost/uuid/uuid.hpp>
#include <cstdlib>
#include <functional>
#include <map>
 
 
namespace gtirb {
 
using UUID = boost::uuids::uuid;
 
class Node;
class CfgNode;
class ByteInterval;
class CodeBlock;
class DataBlock;
class IR;
class Module;
class ProxyBlock;
class Section;
class Symbol;
 
class GTIRB_EXPORT_API Context {
  // Note: this must be declared first so it outlives the allocators. They
  // will access the UuidMap during their destructors to unregister nodes.
  std::map<UUID, Node*> UuidMap;
 
  // Allocate each node type in a separate arena.
  mutable SpecificBumpPtrAllocator<Node> NodeAllocator;
  mutable SpecificBumpPtrAllocator<ByteInterval> ByteIntervalAllocator;
  mutable SpecificBumpPtrAllocator<CodeBlock> CodeBlockAllocator;
  mutable SpecificBumpPtrAllocator<DataBlock> DataBlockAllocator;
  mutable SpecificBumpPtrAllocator<IR> IrAllocator;
  mutable SpecificBumpPtrAllocator<Module> ModuleAllocator;
  mutable SpecificBumpPtrAllocator<ProxyBlock> ProxyBlockAllocator;
  mutable SpecificBumpPtrAllocator<Section> SectionAllocator;
  mutable SpecificBumpPtrAllocator<Symbol> SymbolAllocator;
 
  friend class Node;
 
  void registerNode(const UUID& ID, Node* N) { UuidMap[ID] = N; }
 
  void unregisterNode(const Node* N);
  const Node* findNode(const UUID& ID) const;
  Node* findNode(const UUID& ID);
 
  template <class T> void* Allocate() const;
 
  void Deallocate(void*, size_t) const {
    // Noop -- we don't want callers to deallocate individual allocations, but
    // should instead deallocate the entire Context object to free memory.
  }
 
public:
  Context();
  ~Context();
 
  void ForgetAllocations();
 
  template <typename NodeTy, typename... Args>
  NodeTy* Create(Args&&... TheArgs) {
    return new (Allocate<NodeTy>()) NodeTy(std::forward<Args>(TheArgs)...);
  }
};
 
template <> GTIRB_EXPORT_API void* Context::Allocate<Node>() const;
template <> GTIRB_EXPORT_API void* Context::Allocate<ByteInterval>() const;
template <> GTIRB_EXPORT_API void* Context::Allocate<CodeBlock>() const;
template <> GTIRB_EXPORT_API void* Context::Allocate<DataBlock>() const;
template <> GTIRB_EXPORT_API void* Context::Allocate<IR>() const;
template <> GTIRB_EXPORT_API void* Context::Allocate<Module>() const;
template <> GTIRB_EXPORT_API void* Context::Allocate<ProxyBlock>() const;
template <> GTIRB_EXPORT_API void* Context::Allocate<Section>() const;
template <> GTIRB_EXPORT_API void* Context::Allocate<Symbol>() const;
 
} // namespace gtirb
 
namespace std {
 
template <> struct hash<::gtirb::UUID> {
  size_t operator()(const ::gtirb::UUID& UID) const {
    return ::boost::hash<::gtirb::UUID>()(UID);
  }
};
 
} // namespace std
 
#endif // GTIRB_CONTEXT_H