Replace insns with insts for list of assembly instructions

internal/binutils/disasm_test.go

 	const objdump = "testdata/wrapper/objdump"
 
 	for _, tc := range testcases {
-		insns, err := disassemble([]byte(tc.asm))
+		insts, err := disassemble([]byte(tc.asm))
 		if err != nil {
 			t.Fatalf("FunctionAssembly: %v", err)
 		}
 
-		if len(insns) != len(tc.want) {
-			t.Errorf("Unexpected number of assembly instructions %d (want %d)\n", len(insns), len(tc.want))
+		if len(insts) != len(tc.want) {
+			t.Errorf("Unexpected number of assembly instructions %d (want %d)\n", len(insts), len(tc.want))
 		}
-		for i := range insns {
-			if insns[i] != tc.want[i] {
-				t.Errorf("Expected symbol %v, got %v\n", tc.want[i], insns[i])
+		for i := range insts {
+			if insts[i] != tc.want[i] {
+				t.Errorf("Expected symbol %v, got %v\n", tc.want[i], insts[i])
 			}
 		}
 	}

internal/report/report.go

 		flatSum, cumSum := sns.Sum()
 
 		// Get the function assembly.
-		insns, err := obj.Disasm(s.sym.File, s.sym.Start, s.sym.End)
+		insts, err := obj.Disasm(s.sym.File, s.sym.Start, s.sym.End)
 		if err != nil {
 			return err
 		}
 
-		ns := annotateAssembly(insns, sns, s.base)
+		ns := annotateAssembly(insts, sns, s.base)
 
 		fmt.Fprintf(w, "ROUTINE ======================== %s\n", s.sym.Name[0])
 		for _, name := range s.sym.Name[1:] {
 // annotateAssembly annotates a set of assembly instructions with a
 // set of samples. It returns a set of nodes to display. base is an
 // offset to adjust the sample addresses.
-func annotateAssembly(insns []plugin.Inst, samples graph.Nodes, base uint64) []assemblyInstruction {
+func annotateAssembly(insts []plugin.Inst, samples graph.Nodes, base uint64) []assemblyInstruction {
 	// Add end marker to simplify printing loop.
-	insns = append(insns, plugin.Inst{
+	insts = append(insts, plugin.Inst{
 		Addr: ^uint64(0),
 	})
 
 	samples.Sort(graph.AddressOrder)
 
 	s := 0
-	asm := make([]assemblyInstruction, 0, len(insns))
-	for ix, in := range insns[:len(insns)-1] {
+	asm := make([]assemblyInstruction, 0, len(insts))
+	for ix, in := range insts[:len(insts)-1] {
 		n := assemblyInstruction{
 			address:     in.Addr,
 			instruction: in.Text,
 
 		// Sum all the samples until the next instruction (to account
 		// for samples attributed to the middle of an instruction).
-		for next := insns[ix+1].Addr; s < len(samples) && samples[s].Info.Address-base < next; s++ {
+		for next := insts[ix+1].Addr; s < len(samples) && samples[s].Info.Address-base < next; s++ {
 			sample := samples[s]
 			n.flatDiv += sample.FlatDiv
 			n.flat += sample.Flat

internal/report/source.go

 	}
 
 	// Extract assembly for matched symbol
-	insns, err := obj.Disasm(o.sym.File, o.sym.Start, o.sym.End)
+	insts, err := obj.Disasm(o.sym.File, o.sym.Start, o.sym.End)
 	if err != nil {
 		return assembly
 	}
 
 	srcBase := filepath.Base(src)
-	anodes := annotateAssembly(insns, rs, o.base)
+	anodes := annotateAssembly(insts, rs, o.base)
 	var lineno = 0
 	for _, an := range anodes {
 		if filepath.Base(an.file) == srcBase {
 func getMissingFunctionSource(filename string, asm map[int][]assemblyInstruction, start, end int) (graph.Nodes, string) {
 	var fnodes graph.Nodes
 	for i := start; i <= end; i++ {
-		insns := asm[i]
-		if len(insns) == 0 {
+		insts := asm[i]
+		if len(insts) == 0 {
 			continue
 		}
 		var group assemblyInstruction
-		for _, insn := range insns {
+		for _, insn := range insts {
 			group.flat += insn.flat
 			group.cum += insn.cum
 			group.flatDiv += insn.flatDiv