Add call instructions to Subzero's bitcode reader.

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.
 //
 //===----------------------------------------------------------------------===//
 //
 // This file declares the Inst class and its target-independent
@@ skipping 278 matching lines @@
 
   CfgNode *const TargetFalse; // Doubles as unconditional branch target
   CfgNode *const TargetTrue;  // NULL if unconditional branch
 };
 
 // Call instruction.  The call target is captured as getSrc(0), and
 // arg I is captured as getSrc(I+1).
 class InstCall : public Inst {
 public:
   static InstCall *create(Cfg *Func, SizeT NumArgs, Variable *Dest,
-                          Operand *CallTarget) {
+                          Operand *CallTarget, bool hasTailCall = false) {

[Jim Stichnoth, 2014/09/18 21:41:54]

Can you make this a non-default argument?  I think there's only one other place
that would need to be changed.

[Karl, 2014/09/18 22:01:50]

Done.

     // Set HasSideEffects to true so that the call instruction can't be
     // dead-code eliminated. IntrinsicCalls can override this if the
     // particular intrinsic is deletable and has no side-effects.
     const bool HasSideEffects = true;
     const InstKind Kind = Inst::Call;
-    return new (Func->allocateInst<InstCall>())
-        InstCall(Func, NumArgs, Dest, CallTarget, HasSideEffects, Kind);
+    return new (Func->allocateInst<InstCall>()) InstCall(
+        Func, NumArgs, Dest, CallTarget, hasTailCall, HasSideEffects, Kind);
   }
   void addArg(Operand *Arg) { addSource(Arg); }
   Operand *getCallTarget() const { return getSrc(0); }
   Operand *getArg(SizeT I) const { return getSrc(I + 1); }
   SizeT getNumArgs() const { return getSrcSize() - 1; }
+  bool isTailcall() const { return hasTailCall; }
   virtual void dump(const Cfg *Func) const;
   static bool classof(const Inst *Inst) { return Inst->getKind() == Call; }
+  Type getReturnType() const;
 
 protected:
   InstCall(Cfg *Func, SizeT NumArgs, Variable *Dest, Operand *CallTarget,
-           bool HasSideEff, InstKind Kind)
+           bool HasTailCl, bool HasSideEff, InstKind Kind)

[jvoung (off chromium), 2014/09/18 22:04:46]

nit: I think we might as well just make the argument name "HasTailCall" and
"HasSideEffects"?

[Karl, 2014/09/19 20:29:51]

I agree with using HasTailCall. Changing field back.

       : Inst(Func, Kind, NumArgs + 1, Dest) {
+    hasTailCall = HasTailCl;
     HasSideEffects = HasSideEff;
     addSource(CallTarget);
   }
   virtual ~InstCall() {}
 
 private:
+  bool hasTailCall;

[Jim Stichnoth, 2014/09/18 21:41:54]

Capitalize per LLVM convention.

Also, small nit - isn't it more proper to say it *is* a tail call, rather than
it *has* a tail call?

So may I suggest:
  IsTailCall for the field name
  TailCall for the create()/ctor arg

[Karl, 2014/09/18 22:01:50]

Done.

   InstCall(const InstCall &) LLVM_DELETED_FUNCTION;
   InstCall &operator=(const InstCall &) LLVM_DELETED_FUNCTION;
 };
 
 // Cast instruction (a.k.a. conversion operation).
 class InstCast : public Inst {
 public:
   enum OpKind {
 #define X(tag, str) tag,
     ICEINSTCAST_TABLE
@@ skipping 133 matching lines @@
   }
   static bool classof(const Inst *Inst) {
     return Inst->getKind() == IntrinsicCall;
   }
 
   Intrinsics::IntrinsicInfo getIntrinsicInfo() const { return Info; }
 
 private:
   InstIntrinsicCall(Cfg *Func, SizeT NumArgs, Variable *Dest,
                     Operand *CallTarget, const Intrinsics::IntrinsicInfo &Info)
-      : InstCall(Func, NumArgs, Dest, CallTarget, Info.HasSideEffects,
+      : InstCall(Func, NumArgs, Dest, CallTarget, false, Info.HasSideEffects,
                  Inst::IntrinsicCall),
         Info(Info) {}
   InstIntrinsicCall(const InstIntrinsicCall &) LLVM_DELETED_FUNCTION;
   InstIntrinsicCall &operator=(const InstIntrinsicCall &) LLVM_DELETED_FUNCTION;
   virtual ~InstIntrinsicCall() {}
   const Intrinsics::IntrinsicInfo Info;
 };
 
 // Load instruction.  The source address is captured in getSrc(0).
 class InstLoad : public Inst {
@@ skipping 273 matching lines @@
     assert(Kind >= Target);
   }
   InstTarget(const InstTarget &) LLVM_DELETED_FUNCTION;
   InstTarget &operator=(const InstTarget &) LLVM_DELETED_FUNCTION;
   virtual ~InstTarget() {}
 };
 
 } // end of namespace Ice
 
 #endif // SUBZERO_SRC_ICEINST_H