Add support for op_tuple_fragment in SIL DIExpression and SIL SROA

rdar://124034536

Author: Snowy1803

docs/SIL.rst

@@ -4325,6 +4325,7 @@ from that of source variable.
   debug-info-expr   ::= di-expr-operand (':' di-expr-operand)*
   di-expr-operand   ::= di-expr-operator (':' sil-operand)*
   di-expr-operator  ::= 'op_fragment'
+  di-expr-operator  ::= 'op_tuple_fragment'
   di-expr-operator  ::= 'op_deref'
 
 SIL debug info expression (SIL DIExpression) is a powerful method to connect SSA
@@ -4372,6 +4373,10 @@ a field declaration -- which references the desired sub-field in source variable
 In the snippet above, source variable "the_struct" has an aggregate type ``$MyStruct`` and we use a SIL DIExpression with ``op_fragment`` operator to associate ``%1`` to the ``y`` member variable (via the ``#MyStruct.y`` directive) inside "the_struct".
 Note that the extra source location directive follows right after ``name "the_struct"`` indicate that "the_struct" was originally declared in line 8, but not until line 9 -- the current ``debug_value`` instruction's source location -- does member ``y`` got updated with SSA value ``%1``.
 
+For tuples, it works similarly, except we use ``op_tuple_fragment``, which takes two arguments: the tuple type and the index. If our struct was instead a tuple, we would have:
+
+  debug_value %1 : $Int, var, (name "the_tuple", loc "file.swift":8:7), type $(x: Int, y: Int), expr op_tuple_fragment:$(x: Int, y: Int):1, loc "file.swift":9:4
+
 It is worth noting that a SIL DIExpression is similar to
 `!DIExpression <https://www.llvm.org/docs/LangRef.html#diexpression>`_ in LLVM debug
 info metadata. While LLVM represents ``!DIExpression`` are a list of 64-bit integers,

include/swift/SIL/SILDebugInfoExpression.h

@@ -40,7 +40,7 @@ enum class SILDIExprOperator : unsigned {
   /// associated source variable. This operator takes a single
   /// VarDecl operand pointing to the field declaration.
   /// Note that this directive can only appear at the end of an
-  /// expression.
+  /// expression, along with `TupleFragment`.
   Fragment,
   /// Perform arithmetic addition on the top two elements of the
   /// expression stack and push the result back to the stack.
@@ -51,7 +51,13 @@ enum class SILDIExprOperator : unsigned {
   /// Push an unsigned integer constant onto the stack.
   ConstUInt,
   /// Push a signed integer constant onto the stack.
-  ConstSInt
+  ConstSInt,
+  /// Specifies that the SSA value is an element of the
+  /// associated tuple. This operator takes a TupleType
+  /// operand pointing to the tuple type, and the index of the element.
+  /// Note that this directive can only appear at the end of an
+  /// expression, along with `Fragment`.
+  TupleFragment
 };
 
 /// Represents a single component in a debug info expression.
@@ -64,7 +70,9 @@ struct SILDIExprElement {
     DeclKind,
     /// An integer constant value. Note that
     /// we don't specify its signedness here.
-    ConstIntKind
+    ConstIntKind,
+    /// An operand that has `Type` type.
+    TypeKind
   };
 
 private:
@@ -74,6 +82,7 @@ struct SILDIExprElement {
     SILDIExprOperator Operator;
     Decl *Declaration;
     uint64_t ConstantInt;
+    Type TypePtr;
   };
 
   explicit SILDIExprElement(Kind OpK) : OpKind(OpK) {}
@@ -94,6 +103,8 @@ struct SILDIExprElement {
       return {};
   }
 
+  Type getAsType() const { return OpKind == TypeKind ? TypePtr : nullptr; }
+
   static SILDIExprElement createOperator(SILDIExprOperator Op) {
     SILDIExprElement DIOp(OperatorKind);
     DIOp.Operator = Op;
@@ -111,6 +122,12 @@ struct SILDIExprElement {
     DIOp.ConstantInt = V;
     return DIOp;
   }
+
+  static SILDIExprElement createType(Type T) {
+    SILDIExprElement DIOp(TypeKind);
+    DIOp.TypePtr = T;
+    return DIOp;
+  }
 };
 
 /// Returns the hashcode for the di expr element.
@@ -267,20 +284,27 @@ class SILDebugInfoExpression {
   /// Return true if this expression is not empty
   inline operator bool() const { return Elements.size(); }
 
-  /// Create a op_fragment expression
+  /// Create a `op_fragment` expression
   static SILDebugInfoExpression createFragment(VarDecl *Field);
 
+  /// Create a `op_tuple_fragment` expression
+  static
+  SILDebugInfoExpression createTupleFragment(TupleType *TypePtr, unsigned Idx);
+
   /// Return true if this DIExpression starts with op_deref
   bool startsWithDeref() const {
     return Elements.size() &&
            Elements[0].getAsOperator() == SILDIExprOperator::Dereference;
   }
 
-  /// Return true if this DIExpression has op_fragment (at the end)
+  /// Return true if this DIExpression has a fragment (at the end)
   bool hasFragment() const {
-    return Elements.size() >= 2 &&
+    return (Elements.size() >= 2 &&
            Elements[Elements.size() - 2].getAsOperator() ==
-            SILDIExprOperator::Fragment;
+            SILDIExprOperator::Fragment) ||
+            (Elements.size() >= 3 &&
+             Elements[Elements.size() - 3].getAsOperator() ==
+             SILDIExprOperator::TupleFragment);
   }
 };
 

lib/IRGen/IRGenDebugInfo.cpp

@@ -18,6 +18,7 @@
 #include "GenEnum.h"
 #include "GenOpaque.h"
 #include "GenStruct.h"
+#include "GenTuple.h"
 #include "GenType.h"
 #include "IRBuilder.h"
 #include "swift/AST/ASTDemangler.h"
@@ -232,6 +233,9 @@ class IRGenDebugInfoImpl : public IRGenDebugInfo {
   /// Return false if we fail to create the right DW_OP_LLVM_fragment operand.
   bool handleFragmentDIExpr(const SILDIExprOperand &CurDIExprOp,
                             llvm::DIExpression::FragmentInfo &Fragment);
+  /// Return false if we fail to create the right DW_OP_LLVM_fragment operand.
+  bool handleTupleFragmentDIExpr(const SILDIExprOperand &CurDIExprOp,
+                                 llvm::DIExpression::FragmentInfo &Fragment);
   /// Return false if we fail to create the desired !DIExpression.
   bool buildDebugInfoExpression(const SILDebugVariable &VarInfo,
                                 SmallVectorImpl<uint64_t> &Operands,
@@ -2928,10 +2932,12 @@ void IRGenDebugInfoImpl::emitOutlinedFunction(IRBuilder &Builder,
 bool IRGenDebugInfoImpl::handleFragmentDIExpr(
     const SILDIExprOperand &CurDIExprOp,
     llvm::DIExpression::FragmentInfo &Fragment) {
+  if (CurDIExprOp.getOperator() == SILDIExprOperator::TupleFragment)
+    return handleTupleFragmentDIExpr(CurDIExprOp, Fragment);
   assert(CurDIExprOp.getOperator() == SILDIExprOperator::Fragment);
   // Expecting a VarDecl that points to a field in an struct
   auto DIExprArgs = CurDIExprOp.args();
-  auto *VD = dyn_cast_or_null<VarDecl>(DIExprArgs.size()?
+  auto *VD = dyn_cast_or_null<VarDecl>(DIExprArgs.size() ?
                                        DIExprArgs[0].getAsDecl() : nullptr);
   assert(VD && "Expecting a VarDecl as the operand for "
                "DIExprOperator::Fragment");
@@ -2965,6 +2971,39 @@ bool IRGenDebugInfoImpl::handleFragmentDIExpr(
   return true;
 }
 
+bool IRGenDebugInfoImpl::handleTupleFragmentDIExpr(
+    const SILDIExprOperand &CurDIExprOp,
+    llvm::DIExpression::FragmentInfo &Fragment) {
+  assert(CurDIExprOp.getOperator() == SILDIExprOperator::TupleFragment);
+  // Expecting a TupleType followed by an index
+  auto DIExprArgs = CurDIExprOp.args();
+  assert(DIExprArgs.size() >= 2 && "Expecting two arguments for "
+         "DIExprOperator::TupleFragment");
+  auto *TT = dyn_cast<TupleType>(DIExprArgs[0].getAsType().getPointer());
+  assert(TT && "Expecting a TupleType as the first operand for "
+               "DIExprOperator::TupleFragment");
+  auto Idx = DIExprArgs[1].getAsConstInt();
+  assert(Idx && "Expecting an index as the second operand for "
+               "DIExprOperator::TupleFragment");
+  // Translate the based type
+  SILType ParentSILType = IGM.getLoweredType(TT);
+  // Retrieve the offset & size of the field
+  auto Offset = getFixedTupleElementOffset(IGM, ParentSILType, *Idx);
+  auto ElementType = TT->getElement(*Idx).getType()->getCanonicalType();
+  llvm::Type *FieldTy = IGM.getStorageTypeForLowered(ElementType);
+  // Doesn't support non-fixed type right now
+  if (!Offset || !FieldTy)
+    return false;
+
+  uint64_t SizeInBits = IGM.DataLayout.getTypeSizeInBits(FieldTy);
+  uint64_t OffsetInBits = Offset->getValueInBits();
+
+  // Translate to DW_OP_LLVM_fragment operands
+  Fragment = {SizeInBits, OffsetInBits};
+
+  return true;
+}
+
 bool IRGenDebugInfoImpl::buildDebugInfoExpression(
     const SILDebugVariable &VarInfo, SmallVectorImpl<uint64_t> &Operands,
     llvm::DIExpression::FragmentInfo &Fragment) {
@@ -2975,6 +3014,7 @@ bool IRGenDebugInfoImpl::buildDebugInfoExpression(
     llvm::DIExpression::FragmentInfo SubFragment = {0, 0};
     switch (ExprOperand.getOperator()) {
     case SILDIExprOperator::Fragment:
+    case SILDIExprOperator::TupleFragment:
       if (!handleFragmentDIExpr(ExprOperand, SubFragment))
         return false;
       assert(!Fragment.SizeInBits

lib/SIL/IR/SILDebugInfoExpression.cpp

@@ -37,6 +37,9 @@ const SILDIExprInfo *SILDIExprInfo::get(SILDIExprOperator Op) {
   static const std::unordered_map<SILDIExprOperator, SILDIExprInfo> Infos = {
       {SILDIExprOperator::Fragment,
        {"op_fragment", {SILDIExprElement::DeclKind}}},
+      {SILDIExprOperator::TupleFragment,
+       {"op_tuple_fragment",
+         {SILDIExprElement::TypeKind, SILDIExprElement::ConstIntKind}}},
       {SILDIExprOperator::Dereference, {"op_deref", {}}},
       {SILDIExprOperator::Plus, {"op_plus", {}}},
       {SILDIExprOperator::Minus, {"op_minus", {}}},
@@ -71,3 +74,13 @@ SILDebugInfoExpression SILDebugInfoExpression::createFragment(VarDecl *Field) {
       {SILDIExprElement::createOperator(SILDIExprOperator::Fragment),
        SILDIExprElement::createDecl(Field)});
 }
+
+SILDebugInfoExpression
+SILDebugInfoExpression::createTupleFragment(TupleType *TypePtr, unsigned Idx) {
+  assert(TypePtr);
+  return SILDebugInfoExpression(
+      {SILDIExprElement::createOperator(SILDIExprOperator::TupleFragment),
+       SILDIExprElement::createType(TypePtr),
+       SILDIExprElement::createConstInt(Idx)});
+}
+

lib/SIL/IR/SILPrinter.cpp

@@ -1388,6 +1388,11 @@ class SILPrinter : public SILInstructionVisitor<SILPrinter> {
             *this << V;
           break;
         }
+        case SILDIExprElement::TypeKind: {
+          const Type TypePtr = Arg.getAsType();
+          *this << "$";
+          TypePtr->print(PrintState.OS, PrintState.ASTOptions);
+        }
         }
       }
     }

lib/SIL/Parser/ParseSIL.cpp

@@ -1507,7 +1507,8 @@ bool SILParser::parseSILDebugInfoExpression(SILDebugInfoExpression &DIExpr) {
     SILDIExprOperator::Plus,
     SILDIExprOperator::Minus,
     SILDIExprOperator::ConstUInt,
-    SILDIExprOperator::ConstSInt
+    SILDIExprOperator::ConstSInt,
+    SILDIExprOperator::TupleFragment
   };
 
   do {
@@ -1557,6 +1558,18 @@ bool SILParser::parseSILDebugInfoExpression(SILDebugInfoExpression &DIExpr) {
           DIExpr.push_back(NewOperand);
           break;
         }
+        case SILDIExprElement::TypeKind: {
+          SILType Result;
+          if (parseSILType(Result)) {
+            P.diagnose(P.Tok.getLoc(), diag::sil_dbg_expr_expect_operand_kind,
+                       OpText, "type");
+            return true;
+          }
+          auto NewOperand = SILDIExprElement::createType(
+            Result.getASTType().getPointer());
+          DIExpr.push_back(NewOperand);
+          break;
+        }
         default:
           P.diagnose(P.Tok.getLoc(), diag::sil_dbg_unknown_expr_part,
                      "operand kind");

lib/SIL/Verifier/SILVerifier.cpp

@@ -1487,7 +1487,8 @@ class SILVerifier : public SILVerifierBase<SILVerifier> {
           require(It != ItEnd && (It++)->getKind() == OpK,
                   "di-expression operand kind mismatch");
 
-        if (Op == SILDIExprOperator::Fragment)
+        if (Op == SILDIExprOperator::Fragment ||
+            Op == SILDIExprOperator::TupleFragment)
           HasFragment = true;
         else
           require(!HasFragment, "no directive allowed after op_fragment"

lib/SILOptimizer/Transforms/SILSROA.cpp

@@ -196,14 +196,19 @@ createAllocas(llvm::SmallVector<AllocStackInst *, 4> &NewAllocations) {
   SILBuilderWithScope B(AI);
   SILType Type = AI->getType().getObjectType();
 
-  // Intentionally dropping the debug info.
+  // Intentionally dropping the debug location.
   SILLocation Loc = RegularLocation::getAutoGeneratedLocation();
   if (TT) {
-    // TODO: Add op_fragment support for tuple type
     for (unsigned EltNo : indices(TT->getElementTypes())) {
+      std::optional<SILDebugVariable> NewDebugVarInfo =
+          SILDebugVariable::createFromAllocation(AI);
+      if (NewDebugVarInfo)
+        NewDebugVarInfo->DIExpr.append(
+            SILDebugInfoExpression::createTupleFragment(TT, EltNo));
       SILType EltTy = Type.getTupleElementType(EltNo);
       NewAllocations.push_back(B.createAllocStack(
-          Loc, EltTy, {}, AI->hasDynamicLifetime(), AI->isLexical()));
+          Loc, EltTy, NewDebugVarInfo, AI->hasDynamicLifetime(),
+          AI->isLexical()));
     }
   } else {
     assert(SD && "SD should not be null since either it or TT must be set at "

test/DebugInfo/sroa_mem2reg_tuple.sil

@@ -0,0 +1,80 @@
+// RUN: %target-sil-opt -enable-sil-verify-all -sil-print-debuginfo -sroa %s | %FileCheck --check-prefix=CHECK-SROA %s
+// RUN: %target-sil-opt -enable-sil-verify-all -sil-print-debuginfo -sroa -mem2reg %s -o %t.sil
+// RUN: %FileCheck --check-prefix=CHECK-MEM2REG %s --input-file=%t.sil
+// RUN: %target-swiftc_driver -Xfrontend -disable-debugger-shadow-copies -g -emit-ir %t.sil | %FileCheck --check-prefix=CHECK-IR %s
+// RUN: %target-swiftc_driver -Xfrontend -disable-debugger-shadow-copies -g -c %t.sil -o %t.o
+// RUN: %llvm-dwarfdump --debug-info %t.o | %FileCheck --check-prefix=CHECK-DWARF %s
+sil_stage canonical
+
+import Builtin
+import Swift
+
+sil_scope 2 { loc "sroa.swift":1:6 parent @foo : $@convention(thin) (Int, Int) -> Int }
+sil_scope 3 { loc "sroa.swift":2:7 parent 2 }
+sil_scope 4 { loc "sroa.swift":2:16 parent 2 }
+
+// foo(in_x:in_y:), loc "sroa.swift":1:6, scope 2
+sil hidden @foo : $@convention(thin) (Int, Int) -> Int {
+bb0(%0 : $Int, %1 : $Int):
+  debug_value %0 : $Int, let, name "in_x", argno 1, loc "sroa.swift":1:10, scope 2
+  debug_value %1 : $Int, let, name "in_y", argno 2, loc "sroa.swift":1:21, scope 2
+
+  %4 = alloc_stack $(x: Int, y: Int), var, name "my_tup", loc "sroa.swift":2:7, scope 3
+  // Make sure SROA propagate the debug info to the splitted alloc_stack instructions
+  // CHECK-SROA: alloc_stack $Builtin.Int64, var
+  // CHECK-SROA-SAME:        (name "my_tup", loc "sroa.swift":2:7
+  // CHECK-SROA-SAME:        type $*(x: Int, y: Int), expr op_tuple_fragment:$(x: Int, y: Int):0:op_fragment:#Int._value
+  // CHECK-SROA-SAME:        loc * "<compiler-generated>":0:0
+  // CHECK-SROA: alloc_stack $Builtin.Int64, var
+  // CHECK-SROA-SAME:        (name "my_tup", loc "sroa.swift":2:7
+  // CHECK-SROA-SAME:        type $*(x: Int, y: Int), expr op_tuple_fragment:$(x: Int, y: Int):1:op_fragment:#Int._value
+  // CHECK-SROA-SAME:        loc * "<compiler-generated>":0:0
+
+  // Make sure the struct fields' SSA values are properly connected to the source variables via op_fragment
+  %5 = tuple_element_addr %4 : $*(x: Int, y: Int), 0, loc "sroa.swift":2:16, scope 4
+  %6 = tuple_element_addr %4 : $*(x: Int, y: Int), 1, loc "sroa.swift":2:16, scope 4
+  %7 = integer_literal $Builtin.Int64, 0, loc "sroa.swift":2:20, scope 4
+  %8 = struct $Int (%7 : $Builtin.Int64), loc "sroa.swift":2:20, scope 4
+  // CHECK-MEM2REG: %[[FIELD_X:[0-9]+]] = struct_extract %[[INT_X:[0-9]+]] : $Int, #Int._value, loc "sroa.swift":2:20
+  // CHECK-MEM2REG: debug_value %[[FIELD_X]] : $Builtin.Int64, var, (name "my_tup", loc "sroa.swift":2:7, scope 3), type $*(x: Int, y: Int), expr op_tuple_fragment:$(x: Int, y: Int):0:op_fragment:#Int._value
+  store %8 to %5 : $*Int, loc "sroa.swift":2:20, scope 4
+  %10 = integer_literal $Builtin.Int64, 0, loc "sroa.swift":2:26, scope 4
+  %11 = struct $Int (%10 : $Builtin.Int64), loc "sroa.swift":2:26, scope 4
+  // CHECK-MEM2REG: %[[FIELD_Y:[0-9]+]] = struct_extract %[[INT_Y:[0-9]+]] : $Int, #Int._value, loc "sroa.swift":2:26
+  // CHECK-MEM2REG: debug_value %[[FIELD_Y]] : $Builtin.Int64, var, (name "my_tup", loc "sroa.swift":2:7, scope 3), type $*(x: Int, y: Int), expr op_tuple_fragment:$(x: Int, y: Int):1:op_fragment:#Int._value
+  store %11 to %6 : $*Int, loc "sroa.swift":2:26, scope 4
+
+  %14 = tuple_element_addr %4 : $*(x: Int, y: Int), 0, loc "sroa.swift":3:12, scope 3
+  store %0 to %14 : $*Int, loc "sroa.swift":3:12, scope 3
+  %18 = tuple_element_addr %4 : $*(x: Int, y: Int), 1, loc "sroa.swift":4:12, scope 3
+  store %1 to %18 : $*Int, loc "sroa.swift":4:12, scope 3
+
+  // CHECK-IR: call void @llvm.dbg.value(metadata i64 %0
+  // CHECK-IR-SAME:                      metadata ![[MY_TUP_MD:[0-9]+]]
+  // CHECK-IR-SAME:                      !DIExpression(DW_OP_LLVM_fragment, 0, 64)
+  // CHECK-IR: call void @llvm.dbg.value(metadata i64 %1
+  // CHECK-IR-SAME:                      metadata ![[MY_TUP_MD]]
+  // CHECK-IR-SAME:                      !DIExpression(DW_OP_LLVM_fragment, 64, 64)
+
+  // CHECK-IR: call void @llvm.dbg.value(metadata i64 %0, metadata ![[ARG1_MD:[0-9]+]]
+  // CHECK-IR: call void @llvm.dbg.value(metadata i64 %1, metadata ![[ARG2_MD:[0-9]+]]
+
+  dealloc_stack %4 : $*(x: Int, y: Int), loc "sroa.swift":2:7, scope 3
+  return %0 : $Int, loc "sroa.swift":5:3, scope 3
+} // end sil function 'foo'
+
+
+// CHECK-IR: ![[ARG1_MD]] = !DILocalVariable(name: "in_x", arg: 1
+// CHECK-IR-SAME:                            line: 1
+// CHECK-IR: ![[ARG2_MD]] = !DILocalVariable(name: "in_y", arg: 2
+// CHECK-IR-SAME:                            line: 1
+
+// CHECK-IR: ![[MY_TUP_MD]] = !DILocalVariable(name: "my_tup"
+// CHECK-IR-SAME:                              line: 2
+
+// CHECK-DWARF-LABEL:   DW_AT_name    ("foo")
+// CHECK-DWARF:       DW_TAG_variable
+// CHECK-DWARF:         DW_AT_name  ("my_tup")
+// Shouldn't be marked artificial
+// CHECK-DWARF-NOT:     DW_AT_artificial      (true)
+// CHECK-DWARF:       DW_TAG_{{.*}}