Make fixups reference any constant (allow const float/double pool literals).

src/IceDefs.h

 //===- subzero/src/IceDefs.h - Common Subzero declaraions -------*- C++ -*-===//
 //
 //                        The Subzero Code Generator
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 //
 // This file declares various useful types and classes that have
@@ skipping 43 matching lines @@
 class Liveness;
 class Operand;
 class TargetLowering;
 class Variable;
 class VariableDeclaration;
 class VariablesMetadata;
 
 typedef llvm::BumpPtrAllocatorImpl<llvm::MallocAllocator, 1024 * 1024>
 ArenaAllocator;
 
+template <size_t SlabSize>

[Jim Stichnoth, 2015/01/09 22:30:35]

I was wondering if you could just parameterize ArenaAllocator, e.g.

template <size_t SlabSize = 1024 * 1024>
using ArenaAllocator = llvm::BumpPtrAllocatorImpl<llvm::MallocAllocator,
SlabSize>;

and then change the uses of ArenaAllocator to ArenaAllocator<> .

[jvoung (off chromium), 2015/01/09 22:50:19]

Ah yep, that seems to work. Done.

+using SizedArenaAllocator =
+    llvm::BumpPtrAllocatorImpl<llvm::MallocAllocator, SlabSize>;
+
 ArenaAllocator *getCurrentCfgAllocator();
 
 template <typename T> struct CfgLocalAllocator {
   using value_type = T;
   CfgLocalAllocator() = default;
   template <class U> CfgLocalAllocator(const CfgLocalAllocator<U> &) {}
   T *allocate(std::size_t Num) {
     return getCurrentCfgAllocator()->Allocate<T>(Num);
   }
   void deallocate(T *, std::size_t) {}
@@ skipping 91 matching lines @@
   return llvm::make_range(Container.rbegin(), Container.rend());
 }
 template <typename T>
 llvm::iterator_range<typename T::reverse_iterator> reverse_range(T &Container) {
   return llvm::make_range(Container.rbegin(), Container.rend());
 }
 
 } // end of namespace Ice
 
 #endif // SUBZERO_SRC_ICEDEFS_H