Subzero: Remove IceString.

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
@@ skipping 101 matching lines @@
 } // end of namespace Internal
 
 template <class T, class... Args>
 static std::unique_ptr<T> makeUnique(Args &&... TheArgs) {
   return ::Ice::Internal::MakeUniqueEnabler::create<T>(
       std::forward<Args>(TheArgs)...);
 }
 
 #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>>;
@@ skipping 217 matching lines @@
   FT_Elf, /// ELF .o file
   FT_Asm, /// Assembly .s file
   FT_Iasm /// "Integrated assembler" .byte-style .s file
 };
 
 using Ostream = llvm::raw_ostream;
 using Fdstream = llvm::raw_fd_ostream;
 
 using GlobalLockType = std::mutex;
 
+/// LockedPtr is an RAII wrapper that allows automatically locked access to a
+/// given pointer, automatically unlocking it when when the LockedPtr goes out
+/// of scope.
+template <typename T> class LockedPtr {
+  LockedPtr() = delete;
+  LockedPtr(const LockedPtr &) = delete;
+  LockedPtr &operator=(const LockedPtr &) = delete;
+
+public:
+  LockedPtr(T *Value, GlobalLockType *Lock) : Value(Value), Lock(Lock) {
+    Lock->lock();
+  }
+  LockedPtr(LockedPtr &&Other) : Value(Other.Value), Lock(Other.Lock) {
+    Other.Value = nullptr;
+    Other.Lock = nullptr;
+  }
+  ~LockedPtr() { Lock->unlock(); }
+  T *operator->() const { return Value; }
+  T &operator*() const { return *Value; }
+  T *get() { return Value; }
+
+private:
+  T *Value;
+  GlobalLockType *Lock;
+};
+
 enum ErrorCodes { EC_None = 0, EC_Args, EC_Bitcode, EC_Translation };
 
 /// Wrapper around std::error_code for allowing multiple errors to be folded
 /// into one. The current implementation keeps track of the first error, which
 /// is likely to be the most useful one, and this could be extended to e.g.
 /// collect a vector of errors.
 class ErrorCode : public std::error_code {
   ErrorCode(const ErrorCode &) = delete;
   ErrorCode &operator=(const ErrorCode &) = delete;
 
@@ skipping 35 matching lines @@
   RPE_PooledConstantReordering,
   RPE_RegAllocRandomization,
   RPE_num
 };
 
 using RelocOffsetArray = llvm::SmallVector<class RelocOffset *, 4>;
 
 } // end of namespace Ice
 
 #endif // SUBZERO_SRC_ICEDEFS_H