Subzero. Performance tweaks.

src/IceDefs.h

 //===- subzero/src/IceDefs.h - Common Subzero declarations ------*- C++ -*-===//
 //
 //                        The Subzero Code Generator
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 ///
 /// \file
 /// \brief Declares various useful types and classes that have widespread use
 /// across Subzero.
 ///
-/// Every Subzero source file is expected to include IceDefs.h.
-///
 //===----------------------------------------------------------------------===//
 
 #ifndef SUBZERO_SRC_ICEDEFS_H
 #define SUBZERO_SRC_ICEDEFS_H
 
 #include "IceBuildDefs.h" // TODO(stichnot): move into individual files
+#include "IceMemory.h"
 #include "IceTLS.h"
 
 #include "llvm/ADT/ArrayRef.h"
 #include "llvm/ADT/BitVector.h"
 #include "llvm/ADT/ilist.h"
 #include "llvm/ADT/ilist_node.h"
 #include "llvm/ADT/iterator_range.h"
-#include "llvm/ADT/SmallBitVector.h"
 #include "llvm/ADT/SmallVector.h"
 #include "llvm/ADT/STLExtras.h"
-#include "llvm/Support/Allocator.h"
 #include "llvm/Support/Casting.h"
 #include "llvm/Support/ELF.h"
 #include "llvm/Support/raw_ostream.h"
 
 #include <cassert>
 #include <cstdint>
 #include <cstdio>     // snprintf
 #include <functional> // std::less
 #include <limits>
 #include <list>
 #include <map>
 #include <memory>
 #include <mutex>
 #include <string>
 #include <system_error>
 #include <unordered_map>
+#include <unordered_set>
+#include <utility>
 #include <vector>
 
 namespace Ice {
 
 class Assembler;
 class Cfg;
 class CfgNode;
 class Constant;
 class ELFObjectWriter;
 class ELFStreamer;
 class FunctionDeclaration;
 class GlobalContext;
 class GlobalDeclaration;
 class Inst;
 class InstAssign;
 class InstJumpTable;
 class InstPhi;
 class InstSwitch;
 class InstTarget;
 class LiveRange;
 class Liveness;
 class Operand;
 class TargetDataLowering;
 class TargetLowering;
 class Variable;
 class VariableDeclaration;
 class VariablesMetadata;
 
 constexpr char GlobalOffsetTable[] = "_GLOBAL_OFFSET_TABLE_";
-
-template <size_t SlabSize = 1024 * 1024>
-using ArenaAllocator =
-    llvm::BumpPtrAllocatorImpl<llvm::MallocAllocator, SlabSize>;
-
-ArenaAllocator<> *getCurrentCfgAllocator();
-
-template <typename T> struct CfgLocalAllocator {
-  using value_type = T;
-  using pointer = T *;
-  using const_pointer = const T *;
-  using reference = T &;
-  using const_reference = const T &;
-  using size_type = std::size_t;
-  CfgLocalAllocator() = default;
-  template <class U> CfgLocalAllocator(const CfgLocalAllocator<U> &) {}
-  pointer allocate(size_type Num) {
-    return getCurrentCfgAllocator()->Allocate<T>(Num);
-  }
-  void deallocate(pointer, size_type) {}
-  template <class U> struct rebind { typedef CfgLocalAllocator<U> other; };
-  void construct(pointer P, const T &Val) {
-    new (static_cast<void *>(P)) T(Val);
-  }
-  void destroy(pointer P) { P->~T(); }
-};
-template <typename T, typename U>
-inline bool operator==(const CfgLocalAllocator<T> &,
-                       const CfgLocalAllocator<U> &) {
-  return true;
-}
-template <typename T, typename U>
-inline bool operator!=(const CfgLocalAllocator<T> &,
-                       const CfgLocalAllocator<U> &) {
-  return false;
-}
-
 // makeUnique should be used when memory is expected to be allocated from the
 // heap (as opposed to allocated from some Allocator.) It is intended to be
 // used instead of new.
 //
 // The expected usage is as follows
 //
 // class MyClass {
 // public:
 //   static std::unique_ptr<MyClass> create(<ctor_args>) {
 //     return makeUnique<MyClass>(<ctor_args>);
@@ skipping 28 matching lines @@
 #define ENABLE_MAKE_UNIQUE friend struct ::Ice::Internal::MakeUniqueEnabler
 
 using IceString = std::string;
 using InstList = llvm::ilist<Inst>;
 // Ideally PhiList would be llvm::ilist<InstPhi>, and similar for AssignList,
 // but this runs into issues with SFINAE.
 using PhiList = InstList;
 using AssignList = InstList;
 
 // Standard library containers with CfgLocalAllocator.
+template <typename T> using CfgList = std::list<T, CfgLocalAllocator<T>>;
+template <typename T, typename H = std::hash<T>, typename Eq = std::equal_to<T>>
+using CfgUnorderedSet = std::unordered_set<T, H, Eq, CfgLocalAllocator<T>>;
+template <typename T, typename U, typename H = std::hash<T>,
+          typename Eq = std::equal_to<T>>
+using CfgUnorderedMap =
+    std::unordered_map<T, U, H, Eq, CfgLocalAllocator<std::pair<const T, U>>>;
 template <typename T> using CfgVector = std::vector<T, CfgLocalAllocator<T>>;
-template <typename T> using CfgList = std::list<T, CfgLocalAllocator<T>>;
 
 // Containers that are arena-allocated from the Cfg's allocator.
 using OperandList = CfgVector<Operand *>;
 using VarList = CfgVector<Variable *>;
 using NodeList = CfgVector<CfgNode *>;
 
-// Contains that use the default (global) allocator.
+// Containers that use the default (global) allocator.
 using ConstantList = std::vector<Constant *>;
 using FunctionDeclarationList = std::vector<FunctionDeclaration *>;
 using VariableDeclarationList = std::vector<VariableDeclaration *>;
 
 /// SizeT is for holding small-ish limits like number of source operands in an
 /// instruction. It is used instead of size_t (which may be 64-bits wide) when
 /// we want to save space.
 using SizeT = uint32_t;
 
 /// InstNumberT is for holding an instruction number. Instruction numbers are
@@ skipping 127 matching lines @@
   RPE_PooledConstantReordering,
   RPE_RegAllocRandomization,
   RPE_num
 };
 
 using RelocOffsetArray = llvm::SmallVector<class RelocOffset *, 4>;
 
 } // end of namespace Ice
 
 #endif // SUBZERO_SRC_ICEDEFS_H