Iasm and obj lowering for advanced switch lowering.

src/IceCfg.h

 //===- subzero/src/IceCfg.h - Control flow graph ----------------*- 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 the Cfg class, which represents the control flow
 /// graph and the overall per-function compilation context.
 ///
 //===----------------------------------------------------------------------===//
 
 #ifndef SUBZERO_SRC_ICECFG_H
 #define SUBZERO_SRC_ICECFG_H
 
 #include "IceAssembler.h"
 #include "IceClFlags.h"
 #include "IceDefs.h"
 #include "IceGlobalContext.h"
 #include "IceTypes.h"
 
 namespace Ice {
 
+class InstJumpTable;
+
 class Cfg {
   Cfg() = delete;
   Cfg(const Cfg &) = delete;
   Cfg &operator=(const Cfg &) = delete;
 
 public:
   ~Cfg();
 
   static std::unique_ptr<Cfg> create(GlobalContext *Ctx,
                                      uint32_t SequenceNumber) {
@@ skipping 96 matching lines @@
 
   /// \name Manage arguments to the function.
   /// @{
   void addArg(Variable *Arg);
   const VarList &getArgs() const { return Args; }
   VarList &getArgs() { return Args; }
   void addImplicitArg(Variable *Arg);
   const VarList &getImplicitArgs() const { return ImplicitArgs; }
   /// @}
 
+  /// \name Manage the jump tables.
+  /// @{
+  void addJumpTable(InstJumpTable *JumpTable) {
+    JumpTables.emplace_back(JumpTable);
+  }
+  /// @}
+
   /// \name Miscellaneous accessors.
   /// @{
   TargetLowering *getTarget() const { return Target.get(); }
   VariablesMetadata *getVMetadata() const { return VMetadata.get(); }
   Liveness *getLiveness() const { return Live.get(); }
   template <typename T = Assembler> T *getAssembler() const {
     return llvm::dyn_cast<T>(TargetAssembler.get());
   }
   Assembler *releaseAssembler() { return TargetAssembler.release(); }
   std::unique_ptr<VariableDeclarationList> getGlobalInits() {
@@ skipping 69 matching lines @@
 
   /// Adds a call to the ProfileSummary runtime function as the first
   /// instruction in this CFG's entry block.
   void addCallToProfileSummary();
 
   /// Iterates over the basic blocks in this CFG, adding profiling code to each
   /// one of them. It returns a list with all the globals that the profiling
   /// code needs to be defined.
   void profileBlocks();
 
+  /// Delete registered jump table placeholder instructions. This should only be
+  /// called once all repointing has taken palce.

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

palce -> place

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

Done.

+  void deleteJumpTableInsts();
+  /// Iterate through the registered jump tables and emit them.
+  void emitJumpTables();
+
   GlobalContext *Ctx;
   uint32_t SequenceNumber; /// output order for emission
   VerboseMask VMask;
   IceString FunctionName = "";
   Type ReturnType = IceType_void;
   bool IsInternalLinkage = false;
   bool HasError = false;
   bool FocusedTiming = false;
   IceString ErrorMessage = "";
   CfgNode *Entry = nullptr; /// entry basic block
   NodeList Nodes;           /// linearized node list; Entry should be first
   std::vector<IceString> IdentifierNames;
   InstNumberT NextInstNumber;
   VarList Variables;
   VarList Args;         /// subset of Variables, in argument order
   VarList ImplicitArgs; /// subset of Variables
   std::unique_ptr<ArenaAllocator<>> Allocator;
   std::unique_ptr<Liveness> Live;
   std::unique_ptr<TargetLowering> Target;
   std::unique_ptr<VariablesMetadata> VMetadata;
   std::unique_ptr<Assembler> TargetAssembler;
   /// Globals required by this CFG. Mostly used for the profiler's globals.
   std::unique_ptr<VariableDeclarationList> GlobalInits;
+  std::vector<InstJumpTable *> JumpTables;
 
   /// CurrentNode is maintained during dumping/emitting just for
   /// validating Variable::DefNode.  Normally, a traversal over
   /// CfgNodes maintains this, but before global operations like
   /// register allocation, resetCurrentNode() should be called to avoid
   /// spurious validation failures.
   const CfgNode *CurrentNode = nullptr;
 
   /// Maintain a pointer in TLS to the current Cfg being translated.
   /// This is primarily for accessing its allocator statelessly, but
   /// other uses are possible.
   ICE_TLS_DECLARE_FIELD(const Cfg *, CurrentCfg);
 
 public:
   static void TlsInit() { ICE_TLS_INIT_FIELD(CurrentCfg); }
 };
 
 } // end of namespace Ice
 
 #endif // SUBZERO_SRC_ICECFG_H