Iasm and obj lowering for advanced 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
@@ skipping 896 matching lines @@
 class InstJumpTable : public InstHighLevel {
   InstJumpTable() = delete;
   InstJumpTable(const InstJumpTable &) = delete;
   InstJumpTable &operator=(const InstJumpTable &) = delete;
 
 public:
   static InstJumpTable *create(Cfg *Func, SizeT NumTargets, CfgNode *Default) {
     return new (Func->allocate<InstJumpTable>())
         InstJumpTable(Func, NumTargets, Default);
   }
-  void emit(const Cfg *Func) const override;
-  void emitIAS(const Cfg *Func) const override;
   void addTarget(SizeT TargetIndex, CfgNode *Target) {
     assert(TargetIndex < NumTargets);
     Targets[TargetIndex] = Target;
   }
   bool repointEdges(CfgNode *OldNode, CfgNode *NewNode) override;
-  IceString getName(const Cfg *Func) const;
+  SizeT getId() const { return Id; }
+  IceString getName(const Cfg *Func) const {
+    return makeName(Func->getFunctionName(), 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 *Inst) { return Inst->getKind() == JumpTable; }
 
+  static IceString makeName(const IceString &FuncName, SizeT Id) {
+    return ".L" + FuncName + "$jumptable$__" + std::to_string(Id);
+  }
+
 private:
   InstJumpTable(Cfg *Func, SizeT NumTargets, CfgNode *Default);
   void destroy(Cfg *Func) override {
     Func->deallocateArrayOf<CfgNode *>(Targets);
     Inst::destroy(Func);
   }
 
-  const SizeT LabelNumber;
+  const SizeT Id;
   const SizeT NumTargets;
   CfgNode **Targets;
 };
 
 /// 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;
@@ skipping 29 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