ssa: debug info of Array and Slice

cl/_testdata/debug/in.go

@@ -26,8 +26,9 @@ type StructWithAllTypeFields struct {
 	b     bool
 	c64   complex64
 	c128  complex128
-	// slice []int
+	slice []int
-	// arr   [3]int
+	arr   [3]int
+	arr2  [3]E
 	s     string
 	e     E
 	pf    *StructWithAllTypeFields // resursive
@@ -71,8 +72,9 @@ func FuncWithAllTypeParams(
 	b bool,
 	c64 complex64,
 	c128 complex128,
-	// slice []int,
+	slice []int,
-	// arr [3]int,
+	arr [3]int,
+	arr2 [3]E,
 	s string,
 	e E,
 	f StructWithAllTypeFields,
@@ -88,7 +90,7 @@ func FuncWithAllTypeParams(
 		i8, i16, i32, i64, i, u8, u16, u32, u64, u,
 		f32, f64, b,
 		c64, c128,
-		// slice, arr[0:],
+		slice, arr[0:],
 		s,
 		// &e, &f, pf, pi, intr, m, c, err,
 		// fn,
@@ -114,8 +116,9 @@ func main() {
 		b:     true,
 		c64:   13 + 14i,
 		c128:  15 + 16i,
-		// slice: []int{21, 22, 23},
+		slice: []int{21, 22, 23},
-		// arr:   [3]int{24, 25, 26},
+		arr:   [3]int{24, 25, 26},
+		arr2:  [3]E{{i: 27}, {i: 28}, {i: 29}},
 		s:     "hello",
 		e:     E{i: 30},
 		pf:    &StructWithAllTypeFields{},
@@ -136,7 +139,7 @@ func main() {
 		s.i8, s.i16, s.i32, s.i64, s.i, s.u8, s.u16, s.u32, s.u64, s.u,
 		s.f32, s.f64, s.b,
 		s.c64, s.c128,
-		// s.slice, s.arr,
+		s.slice, s.arr, s.arr2,
 		s.s,
 		s.e, s,
 		s.pf, s.pi,

ssa/di.go

@@ -152,7 +152,8 @@ func (b diBuilder) createType(ty Type, pos token.Position) DIType {
 		return b.createBasicType(ty)
 	case *types.Slice:
 		ty := b.prog.rawType(b.prog.rtType("Slice").RawType().Underlying())
-		return b.createStructType(ty, pos)
+		tyElem := b.prog.rawType(t.Elem())
+		return b.createSliceType(ty, tyElem)
 	case *types.Struct:
 		return b.createStructType(ty, pos)
 	case *types.Signature:
@@ -160,7 +161,7 @@ func (b diBuilder) createType(ty Type, pos token.Position) DIType {
 	case *types.Tuple:
 		return b.createBasicType(ty)
 	case *types.Array:
-		return b.createBasicType(ty)
+		return b.createArrayType(ty, t.Len())
 	case *types.Chan:
 		return b.createBasicType(ty)
 	case *types.Map:
@@ -257,7 +258,8 @@ func (b diBuilder) createBasicType(t Type) DIType {
 func (b diBuilder) createStringType(pos token.Position) DIType {
 	ty := b.prog.rtType("String")
 
-	return &aDIType{ll: b.di.CreateStructType(
+	return &aDIType{
+		ll: b.di.CreateStructType(
 			llvm.Metadata{},
 			llvm.DIStructType{
 				Name:        "string",
@@ -270,6 +272,7 @@ func (b diBuilder) createStringType(pos token.Position) DIType {
 							Name:         "data",
 							SizeInBits:   b.prog.SizeOf(b.prog.CStr()) * 8,
 							AlignInBits:  uint32(b.prog.sizes.Alignof(b.prog.CStr().RawType()) * 8),
+							OffsetInBits: b.prog.OffsetOf(ty, 0) * 8,
 							Type:         b.diType(b.prog.CStr(), pos).ll,
 						},
 					),
@@ -277,15 +280,87 @@ func (b diBuilder) createStringType(pos token.Position) DIType {
 						llvm.Metadata{},
 						llvm.DIMemberType{
 							Name:         "len",
-						SizeInBits:  b.prog.SizeOf(b.prog.Int()) * 8,
+							SizeInBits:   b.prog.SizeOf(b.prog.Uint()) * 8,
 							AlignInBits:  uint32(b.prog.sizes.Alignof(b.prog.Uint().RawType()) * 8),
-						Type:        b.diType(b.prog.Int(), pos).ll,
+							OffsetInBits: b.prog.OffsetOf(ty, 1) * 8,
+							Type:         b.diType(b.prog.Uint(), pos).ll,
 						},
 					),
 				},
+			},
+		),
+	}
+}
+
+func (b diBuilder) createArrayType(ty Type, l int64) DIType {
+	tyElem := b.prog.rawType(ty.RawType().(*types.Array).Elem())
+	return &aDIType{ll: b.di.CreateArrayType(llvm.DIArrayType{
+		SizeInBits:  b.prog.SizeOf(ty) * 8,
+		AlignInBits: uint32(b.prog.sizes.Alignof(ty.RawType()) * 8),
+		ElementType: b.diType(tyElem, token.Position{}).ll,
+		Subscripts: []llvm.DISubrange{{
+			Count: l,
+		}},
 	})}
 }
 
+func (b diBuilder) createSliceType(ty, tyElem Type) DIType {
+	pos := token.Position{}
+	diTyElem := b.diType(tyElem, pos)
+
+	diPtrTyElem := b.di.CreatePointerType(
+		llvm.DIPointerType{
+			Name:        tyElem.RawType().String(),
+			Pointee:     diTyElem.ll,
+			SizeInBits:  b.prog.SizeOf(b.prog.Uintptr()) * 8,
+			AlignInBits: uint32(b.prog.sizes.Alignof(b.prog.Uintptr().RawType()) * 8),
+		},
+	)
+
+	return &aDIType{
+		ll: b.di.CreateStructType(
+			llvm.Metadata{},
+			llvm.DIStructType{
+				Name:        ty.RawType().String(),
+				SizeInBits:  b.prog.SizeOf(ty) * 8,
+				AlignInBits: uint32(b.prog.sizes.Alignof(ty.RawType()) * 8),
+				Elements: []llvm.Metadata{
+					b.di.CreateMemberType(
+						llvm.Metadata{},
+						llvm.DIMemberType{
+							Name:         "data",
+							SizeInBits:   b.prog.SizeOf(b.prog.Uintptr()) * 8,
+							AlignInBits:  uint32(b.prog.sizes.Alignof(b.prog.Uintptr().RawType()) * 8),
+							OffsetInBits: b.prog.OffsetOf(ty, 0) * 8,
+							Type:         diPtrTyElem,
+						},
+					),
+					b.di.CreateMemberType(
+						llvm.Metadata{},
+						llvm.DIMemberType{
+							Name:         "len",
+							SizeInBits:   b.prog.SizeOf(b.prog.Uint()) * 8,
+							AlignInBits:  uint32(b.prog.sizes.Alignof(b.prog.Uint().RawType()) * 8),
+							OffsetInBits: b.prog.OffsetOf(ty, 1) * 8,
+							Type:         b.diType(b.prog.Uint(), pos).ll,
+						},
+					),
+					b.di.CreateMemberType(
+						llvm.Metadata{},
+						llvm.DIMemberType{
+							Name:         "cap",
+							SizeInBits:   b.prog.SizeOf(b.prog.Uint()) * 8,
+							AlignInBits:  uint32(b.prog.sizes.Alignof(b.prog.Uint().RawType()) * 8),
+							OffsetInBits: b.prog.OffsetOf(ty, 2) * 8,
+							Type:         b.diType(b.prog.Uint(), pos).ll,
+						},
+					),
+				},
+			},
+		),
+	}
+}
+
 func (b diBuilder) createComplexType(t Type) DIType {
 	var tfield Type
 	if t.RawType().(*types.Basic).Kind() == types.Complex128 {
@@ -542,8 +617,6 @@ const (
 
 func skipType(t types.Type) bool {
 	switch t.(type) {
-	case *types.Slice:
-		return true
 	case *types.Interface:
 		return true
 	case *types.Signature: