Iasm and obj lowering for advanced switch lowering.

src/IceGlobalContext.h

 //===- subzero/src/IceGlobalContext.h - Global context defs -----*- C++ -*-===//
 //
 //                        The Subzero Code Generator
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 ///
 /// \file
 /// This file declares aspects of the compilation that persist across
 /// multiple functions.
 ///
 //===----------------------------------------------------------------------===//
 
 #ifndef SUBZERO_SRC_ICEGLOBALCONTEXT_H
 #define SUBZERO_SRC_ICEGLOBALCONTEXT_H
 
 #include "IceDefs.h"
 #include "IceClFlags.h"
 #include "IceIntrinsics.h"
 #include "IceRNG.h"
+#include "IceSwitchLowering.h"
 #include "IceThreading.h"
 #include "IceTimerTree.h"
 #include "IceTypes.h"
 #include "IceUtils.h"
 
 #include <array>
 #include <functional>
 #include <mutex>
 #include <thread>
 #include <type_traits>
@@ skipping 15 matching lines @@
 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; }
 
 private:
   T *Value;
   GlobalLockType *Lock;
 };
 
 class GlobalContext {
   GlobalContext() = delete;
   GlobalContext(const GlobalContext &) = delete;
   GlobalContext &operator=(const GlobalContext &) = delete;
@@ skipping 134 matching lines @@
   /// Returns an undef.
   Constant *getConstantUndef(Type Ty);
   /// Returns a zero value.
   Constant *getConstantZero(Type Ty);
   /// getConstantPool() returns a copy of the constant pool for
   /// constants of a given type.
   ConstantList getConstantPool(Type Ty);
   /// Returns a copy of the list of external symbols.
   ConstantList getConstantExternSyms();
 
+  /// Return a locked pointer to the registered jump tables.
+  LockedPtr<std::vector<JumpTableData>> getJumpTables() {
+    return LockedPtr<std::vector<JumpTableData>>(&JumpTables, &JumpTablesLock);
+  }
+  /// Create a new jump table entry and return a reference to it.
+  JumpTableData &addJumpTable(IceString FuncName, SizeT Id, SizeT NumTargets) {

[jvoung (off chromium), 2015/07/29 21:31:16]

Maybe outline this instead of having it inline in the .h.

[ascull, 2015/07/29 22:43:04]

Done.

+    LockedPtr<std::vector<JumpTableData>> JumpTables = getJumpTables();
+    JumpTables->emplace_back(FuncName, Id, NumTargets);
+    return JumpTables->back();
+  }
+
   const ClFlags &getFlags() const { return Flags; }
 
   bool isIRGenerationDisabled() const {
     return getFlags().getDisableIRGeneration();
   }
 
   /// Allocate data of type T using the global allocator. We allow entities
   /// allocated from this global allocator to be either trivially or
   /// non-trivially destructible. We optimize the case when T is trivially
   /// destructible by not registering a destructor. Destructors will be invoked
@@ skipping 106 matching lines @@
   /// called or the Sequential flag was set.
   std::unique_ptr<Cfg> optQueueBlockingPop();
   /// Notifies that no more work will be added to the work queue.
   void optQueueNotifyEnd() { OptQ.notifyEnd(); }
 
   /// Emit file header for output file.
   void emitFileHeader();
 
   void lowerConstants();
 
+  void lowerJumpTables();
+
   void emitQueueBlockingPush(EmitterWorkItem *Item);
   EmitterWorkItem *emitQueueBlockingPop();
   void emitQueueNotifyEnd() { EmitQ.notifyEnd(); }
 
   void initParserThread() {
     ThreadContext *Tls = new ThreadContext();
     auto Timers = getTimers();
     Timers->initInto(Tls->Timers);
     AllThreadContexts.push_back(Tls);
     ICE_TLS_SET_FIELD(TLS, Tls);
@@ skipping 101 matching lines @@
   typedef std::vector<std::function<void()>> DestructorArray;
   GlobalLockType DestructorsLock;
   DestructorArray Destructors;
 
   ICE_CACHELINE_BOUNDARY;
   // Managed by getConstantPool()
   GlobalLockType ConstPoolLock;
   std::unique_ptr<ConstantPool> ConstPool;
 
   ICE_CACHELINE_BOUNDARY;
+  // Managed by getJumpTables()
+  GlobalLockType JumpTablesLock;
+  std::vector<JumpTableData> JumpTables;
+
+  ICE_CACHELINE_BOUNDARY;
   // Managed by getErrorStatus()
   GlobalLockType ErrorStatusLock;
   ErrorCode ErrorStatus;
 
   ICE_CACHELINE_BOUNDARY;
   // Managed by getStatsCumulative()
   GlobalLockType StatsLock;
   CodeStats StatsCumulative;
 
   ICE_CACHELINE_BOUNDARY;
@@ skipping 129 matching lines @@
   explicit OstreamLocker(GlobalContext *Ctx) : Ctx(Ctx) { Ctx->lockStr(); }
   ~OstreamLocker() { Ctx->unlockStr(); }
 
 private:
   GlobalContext *const Ctx;
 };
 
 } // end of namespace Ice
 
 #endif // SUBZERO_SRC_ICEGLOBALCONTEXT_H