First pass at emitIAS for branches and binding labels

src/IceInstX8632.h

 //===- subzero/src/IceInstX8632.h - Low-level x86 instructions --*- C++ -*-===//
 //
 //                        The Subzero Code Generator
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 //
 // This file declares the InstX8632 and OperandX8632 classes and
@@ skipping 256 matching lines @@
 
 protected:
   InstX8632(Cfg *Func, InstKindX8632 Kind, SizeT Maxsrcs, Variable *Dest)
       : InstTarget(Func, static_cast<InstKind>(Kind), Maxsrcs, Dest) {}
   ~InstX8632() override {}
   static bool isClassof(const Inst *Inst, InstKindX8632 MyKind) {
     return Inst->getKind() == static_cast<InstKind>(MyKind);
   }
 };
 
 // InstX8632Label represents an intra-block label that is the

[Jim Stichnoth, 2014/10/22 18:01:14]

Document the assumption about short branches to labels.

[jvoung (off chromium), 2014/10/22 20:43:58]

Done.

 // target of an intra-block branch.  These are used for lowering i1
 // calculations, Select instructions, and 64-bit compares on a 32-bit
 // architecture, without basic block splitting.  Basic block splitting
 // is not so desirable for several reasons, one of which is the impact
 // on decisions based on whether a variable's live range spans
 // multiple basic blocks.
 //
 // Intra-block control flow must be used with caution.  Consider the
 // sequence for "c = (a >= b ? x : y)".
 //     cmp a, b
@@ skipping 27 matching lines @@
   InstX8632Label(const InstX8632Label &) = delete;
   InstX8632Label &operator=(const InstX8632Label &) = delete;
 
 public:
   static InstX8632Label *create(Cfg *Func, TargetX8632 *Target) {
     return new (Func->allocate<InstX8632Label>()) InstX8632Label(Func, Target);
   }
   uint32_t getEmitInstCount() const override { return 0; }
   IceString getName(const Cfg *Func) const;
   void emit(const Cfg *Func) const override;
-  // TODO(jvoung): Filler in.
-  void emitIAS(const Cfg *Func) const override { emit(Func); }
+  void emitIAS(const Cfg *Func) const override;
   void dump(const Cfg *Func) const override;
+  x86::Label *getAsmLabel() const { return &AsmLabel; }
 
 private:
   InstX8632Label(Cfg *Func, TargetX8632 *Target);
   ~InstX8632Label() override {}
   SizeT Number; // used only for unique label string generation
+  mutable x86::Label AsmLabel; // modified by emitIAS.

[Jim Stichnoth, 2014/10/22 18:01:14]

Is the mutable aspect "permanent", or just a stop-gap for textual IAS emission?

[jvoung (off chromium), 2014/10/22 20:43:58]

Unfortunately, it is permanent. I wasn't sure of a good way around this. The
issue is that emitIAS() is "const", but it is at that point when it is
convenient to store the buffer position that the AsmLabel represents, and go
through the queue of forward branch fixups needed and flush that queue.

I could store this Label w/ position and queue externally, like the case for
CfgNode labels, then it would still be const.

[Jim Stichnoth, 2014/10/22 21:50:08]

I think that would be a cleaner approach, maybe a vector parallel to
CfgNodeLabels, or make CfgNodeLabels a vector of tuples.

I just think there shouldn't be mutable or const_cast this early in the
project...

[jvoung (off chromium), 2014/10/23 18:05:27]

Okay I agree it's cleaner. It adds a bit of indirection, but at least on my
machine the performance difference is negligible.

Done.

 };
 
 // Conditional and unconditional branch instruction.
 class InstX8632Br : public InstX8632 {
   InstX8632Br(const InstX8632Br &) = delete;
   InstX8632Br &operator=(const InstX8632Br &) = delete;
 
 public:
   // Create a conditional branch to a node.
   static InstX8632Br *create(Cfg *Func, CfgNode *TargetTrue,
@@ skipping 35 matching lines @@
     uint32_t Sum = 0;
     if (Label)
       ++Sum;
     if (getTargetTrue())
       ++Sum;
     if (getTargetFalse())
       ++Sum;
     return Sum;
   }
   void emit(const Cfg *Func) const override;
-  // TODO(jvoung): Filler in.
-  void emitIAS(const Cfg *Func) const override { emit(Func); }
+  void emitIAS(const Cfg *Func) const override;
   void dump(const Cfg *Func) const override;
   static bool classof(const Inst *Inst) { return isClassof(Inst, Br); }
 
 private:
   InstX8632Br(Cfg *Func, const CfgNode *TargetTrue, const CfgNode *TargetFalse,
               const InstX8632Label *Label, CondX86::BrCond Condition);
   ~InstX8632Br() override {}
   CondX86::BrCond Condition;
   const CfgNode *TargetTrue;
   const CfgNode *TargetFalse;
@@ skipping 1144 matching lines @@
 template <> void InstX8632Pinsr::emitIAS(const Cfg *Func) const;
 template <> void InstX8632Movsx::emitIAS(const Cfg *Func) const;
 template <> void InstX8632Movzx::emitIAS(const Cfg *Func) const;
 template <> void InstX8632Pmull::emitIAS(const Cfg *Func) const;
 template <> void InstX8632Pshufd::emitIAS(const Cfg *Func) const;
 template <> void InstX8632Shufps::emitIAS(const Cfg *Func) const;
 
 } // end of namespace Ice
 
 #endif // SUBZERO_SRC_ICEINSTX8632_H