Subzero. Refactors Switch Lowering.

src/IceInst.h

 //===- subzero/src/IceInst.h - High-level instructions ----------*- 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 the Inst class and its target-independent subclasses.
 ///
 /// These represent the high-level Vanilla ICE instructions and map roughly 1:1
 /// to LLVM instructions.
 ///
 //===----------------------------------------------------------------------===//
 
 #ifndef SUBZERO_SRC_ICEINST_H
 #define SUBZERO_SRC_ICEINST_H
 
 #include "IceCfg.h"
 #include "IceDefs.h"
 #include "IceInst.def"
 #include "IceIntrinsics.h"
+#include "IceSwitchLowering.h"
 #include "IceTypes.h"
 
 // TODO: The Cfg structure, and instructions in particular, need to be
 // validated for things like valid operand types, valid branch targets, proper
 // ordering of Phi and non-Phi instructions, etc. Most of the validity checking
 // will be done in the bitcode reader. We need a list of everything that should
 // be validated, and tests for each.
 
 namespace Ice {
 
@@ skipping 899 matching lines @@
   SizeT getId() const { return Id; }
   SizeT getNumTargets() const { return NumTargets; }
   CfgNode *getTarget(SizeT I) const {
     assert(I < NumTargets);
     return Targets[I];
   }
   void dump(const Cfg *Func) const override;
   static bool classof(const Inst *Instr) {
     return Instr->getKind() == JumpTable;
   }
+  // Creates a JumpDataTable struct (used for ELF emission) that represents this
+  // InstJumpTable.
+  JumpTableData toJumpTableData(Assembler *Asm) const;
 
-  // TODO(stichnot): Should this create&save GlobalString values?
-  static std::string makeName(GlobalString FuncName, SizeT Id) {
-    if (FuncName.hasStdString())
-      return ".L" + FuncName + "$jumptable$__" + std::to_string(Id);
-    return ".L" + std::to_string(FuncName.getID()) + "_" + std::to_string(Id);
+  // InstJumpTable is just a placeholder for the switch targets, and it does not
+  // need to emit any code, so we redefine emit and emitIAS to do nothing.
+  void emit(const Cfg *) const override {}
+  void emitIAS(const Cfg * /* Func */) const override {}
+
+  const std::string getName() const {
+    assert(Name.hasStdString());
+    return Name.toString();
   }
 
 private:
   InstJumpTable(Cfg *Func, SizeT NumTargets, CfgNode *Default);
   void destroy(Cfg *Func) override {
     Func->deallocateArrayOf<CfgNode *>(Targets);
     Inst::destroy(Func);
   }
 
   const SizeT Id;
   const SizeT NumTargets;
   CfgNode **Targets;
+  GlobalString Name; // This JumpTable's name in the output.
+  GlobalString FuncName;
 };
 
 /// The Target instruction is the base class for all target-specific
 /// instructions.
 class InstTarget : public Inst {
   InstTarget() = delete;
   InstTarget(const InstTarget &) = delete;
   InstTarget &operator=(const InstTarget &) = delete;
 
 public:
@@ skipping 28 matching lines @@
   static void noteHead(Ice::Inst *, Ice::Inst *) {}
   void deleteNode(Ice::Inst *) {}
 
 private:
   mutable ilist_half_node<Ice::Inst> Sentinel;
 };
 
 } // end of namespace llvm
 
 #endif // SUBZERO_SRC_ICEINST_H