Temporarily Revert "Add an argument-number field to DebugValueInst and friends."

while investigating buildbot breakage.

This reverts commit ed2b16d.

Author: adrian-prantl

include/swift/SIL/SILBuilder.h

@@ -219,11 +219,10 @@ class SILBuilder {
   // SILInstruction Creation Methods
   //===--------------------------------------------------------------------===//
 
-  AllocStackInst *createAllocStack(SILLocation Loc, SILType elementType,
-                                   unsigned ArgNo = 0) {
+  AllocStackInst *createAllocStack(SILLocation Loc, SILType elementType) {
     Loc.markAsPrologue();
     return insert(new (F.getModule()) AllocStackInst(
-        createSILDebugLocation(Loc), elementType, F, ArgNo));
+        createSILDebugLocation(Loc), elementType, F));
   }
 
   AllocRefInst *createAllocRef(SILLocation Loc, SILType elementType, bool objc,
@@ -250,11 +249,10 @@ class SILBuilder {
         createSILDebugLocation(Loc), valueType, operand));
   }
 
-  AllocBoxInst *createAllocBox(SILLocation Loc, SILType ElementType,
-                               unsigned ArgNo = 0) {
+  AllocBoxInst *createAllocBox(SILLocation Loc, SILType ElementType) {
     Loc.markAsPrologue();
     return insert(new (F.getModule()) AllocBoxInst(createSILDebugLocation(Loc),
-                                                   ElementType, F, ArgNo));
+                                                   ElementType, F));
   }
 
   AllocExistentialBoxInst *
@@ -433,16 +431,13 @@ class SILBuilder {
     return insert(
         MarkFunctionEscapeInst::create(createSILDebugLocation(Loc), vars, F));
   }
-
-  DebugValueInst *createDebugValue(SILLocation Loc, SILValue src,
-                                   unsigned ArgNo = 0) {
+  DebugValueInst *createDebugValue(SILLocation Loc, SILValue src) {
     return insert(new (F.getModule())
-                      DebugValueInst(createSILDebugLocation(Loc), src, ArgNo));
+                      DebugValueInst(createSILDebugLocation(Loc), src));
   }
-  DebugValueAddrInst *createDebugValueAddr(SILLocation Loc, SILValue src,
-                                           unsigned ArgNo = 0) {
-    return insert(new (F.getModule()) DebugValueAddrInst(
-        createSILDebugLocation(Loc), src, ArgNo));
+  DebugValueAddrInst *createDebugValueAddr(SILLocation Loc, SILValue src) {
+    return insert(new (F.getModule())
+                      DebugValueAddrInst(createSILDebugLocation(Loc), src));
   }
 
   LoadWeakInst *createLoadWeak(SILLocation Loc, SILValue src, IsTake_t isTake) {

include/swift/SIL/SILCloner.h

@@ -670,9 +670,9 @@ SILCloner<ImplClass>::visitDebugValueInst(DebugValueInst *Inst) {
 
   // Since we want the debug info to survive, we do not remap the location here.
   getBuilder().setCurrentDebugScope(getOpScope(Inst->getDebugScope()));
-  doPostProcess(Inst, getBuilder().createDebugValue(
-                          Inst->getLoc(), getOpValue(Inst->getOperand()),
-                          Inst->getVarInfo().getArgNo()));
+  doPostProcess(Inst,
+                getBuilder().createDebugValue(Inst->getLoc(),
+                                              getOpValue(Inst->getOperand())));
 }
 template<typename ImplClass>
 void
@@ -686,9 +686,9 @@ SILCloner<ImplClass>::visitDebugValueAddrInst(DebugValueAddrInst *Inst) {
   // Do not remap the location for a debug Instruction.
   SILValue OpValue = getOpValue(Inst->getOperand());
   getBuilder().setCurrentDebugScope(getOpScope(Inst->getDebugScope()));
-  doPostProcess(
-      Inst, getBuilder().createDebugValueAddr(Inst->getLoc(), OpValue,
-                                              Inst->getVarInfo().getArgNo()));
+  doPostProcess(Inst,
+                getBuilder().createDebugValueAddr(Inst->getLoc(),
+                                                  OpValue));
 }
 
 

include/swift/SIL/SILInstruction.h

@@ -316,27 +316,14 @@ class UnaryInstructionBase : public BASE {
   typename std::enable_if<has_result<X>::value, SILType>::type
   getType(unsigned i = 0) const { return ValueBase::getType(i); }
 
-  ArrayRef<Operand> getAllOperands() const { return Operands.asArray(); }\
+  ArrayRef<Operand> getAllOperands() const { return Operands.asArray(); }
   MutableArrayRef<Operand> getAllOperands() { return Operands.asArray(); }
 
   static bool classof(const ValueBase *V) {
     return V->getKind() == KIND;
   }
 };
 
-
-/// Holds common debug information about local variables and function
-/// arguments that are needed by DebugValueInst, DebugValueAddrInst,
-/// AllocStackInst, and AllocBoxInst.
-class DebugVariable {
-  /// The source function argument position from left to right
-  /// starting with 1 or 0 if this is a local variable.
-  unsigned char ArgNo;
-public:
-  DebugVariable(unsigned ArgNo) : ArgNo(ArgNo) {};
-  unsigned getArgNo() const { return ArgNo; }
-};
-
 //===----------------------------------------------------------------------===//
 // Allocation Instructions
 //===----------------------------------------------------------------------===//
@@ -381,20 +368,15 @@ class StackPromotable {
 /// reference count) stack memory.  The memory is provided uninitialized.
 class AllocStackInst : public AllocationInst {
   friend class SILBuilder;
-  DebugVariable VarInfo;
 
-  AllocStackInst(SILDebugLocation *Loc, SILType elementType, SILFunction &F,
-                 unsigned ArgNo);
+  AllocStackInst(SILDebugLocation *Loc, SILType elementType, SILFunction &F);
 
 public:
 
   /// getDecl - Return the underlying variable declaration associated with this
   /// allocation, or null if this is a temporary allocation.
   VarDecl *getDecl() const;
 
-  DebugVariable getVarInfo() const { return VarInfo; };
-  void setArgNo(unsigned N) { VarInfo = DebugVariable(N); }
-
   /// getElementType - Get the type of the allocated memory (as opposed to the
   /// (second) type of the instruction itself, which will be an address type).
   SILType getElementType() const {
@@ -481,10 +463,7 @@ class AllocValueBufferInst :
 class AllocBoxInst : public AllocationInst {
   friend class SILBuilder;
 
-  DebugVariable VarInfo;
-
-  AllocBoxInst(SILDebugLocation *DebugLoc, SILType ElementType, SILFunction &F,
-               unsigned ArgNo);
+  AllocBoxInst(SILDebugLocation *DebugLoc, SILType ElementType, SILFunction &F);
 
 public:
 
@@ -499,8 +478,6 @@ class AllocBoxInst : public AllocationInst {
   /// allocation, or null if this is a temporary allocation.
   VarDecl *getDecl() const;
 
-  DebugVariable getVarInfo() const { return VarInfo; };
-
   ArrayRef<Operand> getAllOperands() const { return {}; }
   MutableArrayRef<Operand> getAllOperands() { return {}; }
 
@@ -1364,34 +1341,29 @@ class MarkFunctionEscapeInst : public SILInstruction {
 /// types).
 class DebugValueInst : public UnaryInstructionBase<ValueKind::DebugValueInst> {
   friend class SILBuilder;
-  DebugVariable VarInfo;
 
-  DebugValueInst(SILDebugLocation *DebugLoc, SILValue Operand, unsigned ArgNo)
-      : UnaryInstructionBase(DebugLoc, Operand), VarInfo(ArgNo) {}
+  DebugValueInst(SILDebugLocation *DebugLoc, SILValue Operand)
+      : UnaryInstructionBase(DebugLoc, Operand) {}
 
 public:
   /// getDecl - Return the underlying variable declaration that this denotes,
   /// or null if we don't have one.
   VarDecl *getDecl() const;
-  DebugVariable getVarInfo() const { return VarInfo; }
 };
 
 /// Define the start or update to a symbolic variable value (for address-only
 /// types) .
 class DebugValueAddrInst
   : public UnaryInstructionBase<ValueKind::DebugValueAddrInst> {
   friend class SILBuilder;
-  DebugVariable VarInfo;
 
-  DebugValueAddrInst(SILDebugLocation *DebugLoc, SILValue Operand,
-                     unsigned ArgNo)
-      : UnaryInstructionBase(DebugLoc, Operand), VarInfo(ArgNo) {}
+  DebugValueAddrInst(SILDebugLocation *DebugLoc, SILValue Operand)
+      : UnaryInstructionBase(DebugLoc, Operand) {}
 
 public:
   /// getDecl - Return the underlying variable declaration that this denotes,
   /// or null if we don't have one.
   VarDecl *getDecl() const;
-  DebugVariable getVarInfo() const { return VarInfo; }
 };
 
 

lib/IRGen/DebugTypeInfo.h

@@ -71,11 +71,6 @@ namespace swift {
         if (ValueDecl *D = getDecl()) return D->getDeclContext();
         else return DeclOrContext.get<DeclContext*>();
       }
-
-      void unwrapInOutType() {
-        Type = Type->castTo<InOutType>()->getObjectType().getPointer();
-      }
-
       bool isNull() const { return Type == nullptr; }
       bool operator==(DebugTypeInfo T) const;
       bool operator!=(DebugTypeInfo T) const;