pcln.go

package liblink

import (
	"fmt"
	"log"
)

// Copyright 2013 The Go Authors.  All rights reserved.
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.
func addvarint(ctxt *Link, d *Pcdata, val uint32) {
	var v uint32
	for v = val; v >= 0x80; v >>= 7 {
		d.P = append(d.P, uint8(v|0x80))
	}
	d.P = append(d.P, uint8(v))
}

// funcpctab writes to dst a pc-value table mapping the code in func to the values
// returned by valfunc parameterized by arg. The invocation of valfunc to update the
// current value is, for each p,
//
//	val = valfunc(func, val, p, 0, arg);
//	record val as value at p->pc;
//	val = valfunc(func, val, p, 1, arg);
//
// where func is the function, val is the current value, p is the instruction being
// considered, and arg can be used to further parameterize valfunc.
func funcpctab(ctxt *Link, dst *Pcdata, fun *LSym, desc string, valfunc func(*Link, *LSym, int, *Prog, int, interface{}) int, arg interface{}) {
	var dbg int
	var i int
	var oldval int
	var val int
	var started int
	var delta uint32
	var pc int64
	var p *Prog
	// To debug a specific function, uncomment second line and change name.
	dbg = 0
	//dbg = strcmp(func->name, "main.main") == 0;
	//dbg = strcmp(desc, "pctofile") == 0;
	ctxt.Debugpcln += dbg
	dst.P = dst.P[:0]
	if ctxt.Debugpcln != 0 {
		fmt.Fprintf(ctxt.Bso, "funcpctab %s [valfunc=%s]\n", fun.Name, desc)
	}
	val = -1
	oldval = val
	if fun.Text == nil {
		ctxt.Debugpcln -= dbg
		return
	}
	pc = fun.Text.Pc
	if ctxt.Debugpcln != 0 {
		fmt.Fprintf(ctxt.Bso, "%6x %6d %v\n", uint64(pc), val, fun.Text)
	}
	started = 0
	for p = fun.Text; p != nil; p = p.Link {
		// Update val. If it's not changing, keep going.
		val = valfunc(ctxt, fun, val, p, 0, arg)
		if val == oldval && started != 0 {
			val = valfunc(ctxt, fun, val, p, 1, arg)
			if ctxt.Debugpcln != 0 {
				fmt.Fprintf(ctxt.Bso, "%6x %6s %v\n", uint64(int64(p.Pc)), "", p)
			}
			continue
		}
		// If the pc of the next instruction is the same as the
		// pc of this instruction, this instruction is not a real
		// instruction. Keep going, so that we only emit a delta
		// for a true instruction boundary in the program.
		if p.Link != nil && p.Link.Pc == p.Pc {
			val = valfunc(ctxt, fun, val, p, 1, arg)
			if ctxt.Debugpcln != 0 {
				fmt.Fprintf(ctxt.Bso, "%6x %6s %v\n", uint64(int64(p.Pc)), "", p)
			}
			continue
		}
		// The table is a sequence of (value, pc) pairs, where each
		// pair states that the given value is in effect from the current position
		// up to the given pc, which becomes the new current position.
		// To generate the table as we scan over the program instructions,
		// we emit a "(value" when pc == func->value, and then
		// each time we observe a change in value we emit ", pc) (value".
		// When the scan is over, we emit the closing ", pc)".
		//
		// The table is delta-encoded. The value deltas are signed and
		// transmitted in zig-zag form, where a complement bit is placed in bit 0,
		// and the pc deltas are unsigned. Both kinds of deltas are sent
		// as variable-length little-endian base-128 integers,
		// where the 0x80 bit indicates that the integer continues.
		if ctxt.Debugpcln != 0 {
			fmt.Fprintf(ctxt.Bso, "%6x %6d %v\n", uint64(int64(p.Pc)), val, p)
		}
		if started != 0 {
			addvarint(ctxt, dst, uint32((p.Pc-pc)/int64(ctxt.Arch.Minlc)))
			pc = p.Pc
		}
		delta = uint32(val) - uint32(oldval)
		if delta>>31 != 0 {
			delta = 1 | ^(delta << 1)
		} else {
			delta <<= 1
		}
		addvarint(ctxt, dst, delta)
		oldval = val
		started = 1
		val = valfunc(ctxt, fun, val, p, 1, arg)
	}
	if started != 0 {
		if ctxt.Debugpcln != 0 {
			fmt.Fprintf(ctxt.Bso, "%6x done\n", uint64(int64(fun.Text.Pc)+fun.Size))
		}
		addvarint(ctxt, dst, uint32((fun.Value+fun.Size-pc)/int64(ctxt.Arch.Minlc)))
		addvarint(ctxt, dst, 0) // terminator
	}
	if ctxt.Debugpcln != 0 {
		fmt.Fprintf(ctxt.Bso, "wrote %d bytes to %p\n", len(dst.P), dst)
		for i = 0; i < len(dst.P); i++ {
			fmt.Fprintf(ctxt.Bso, " %02x", dst.P[i])
		}
		fmt.Fprintf(ctxt.Bso, "\n")
	}
	ctxt.Debugpcln -= dbg
}

// pctofileline computes either the file number (arg == 0)
// or the line number (arg == 1) to use at p.
// Because p->lineno applies to p, phase == 0 (before p)
// takes care of the update.
func pctofileline(ctxt *Link, sym *LSym, oldval int, p *Prog, phase int, arg interface{}) int {
	var i int
	var l int
	var f *LSym
	var pcln *Pcln
	if p.As == ctxt.Arch.ATEXT || p.As == ctxt.Arch.ANOP || p.As == ctxt.Arch.AUSEFIELD || p.Lineno == 0 || phase == 1 {
		return oldval
	}
	linkgetline(ctxt, p.Lineno, &f, &l)
	if f == nil {
		//	print("getline failed for %s %P\n", ctxt->cursym->name, p);
		return oldval
	}
	if arg == nil {
		return l
	}
	pcln = arg.(*Pcln)
	if f == pcln.Lastfile {
		return pcln.Lastindex
	}
	for i = 0; i < len(pcln.File); i++ {
		if pcln.File[i] == f {
			pcln.Lastfile = f
			pcln.Lastindex = i
			return i
		}
	}
	pcln.File = append(pcln.File, f)
	pcln.Lastfile = f
	pcln.Lastindex = i
	return i
}

// pctospadj computes the sp adjustment in effect.
// It is oldval plus any adjustment made by p itself.
// The adjustment by p takes effect only after p, so we
// apply the change during phase == 1.
func pctospadj(ctxt *Link, sym *LSym, oldval int, p *Prog, phase int, arg interface{}) int {
	if oldval == -1 { // starting
		oldval = 0
	}
	if phase == 0 {
		return oldval
	}
	if int64(oldval)+p.Spadj < -10000 || int64(oldval)+p.Spadj > 1100000000 {
		ctxt.Diag("overflow in spadj: %d + %d = %d", oldval, p.Spadj, int64(oldval)+p.Spadj)
		log.Fatalf("bad code")
	}
	return int(int64(oldval) + p.Spadj)
}

// pctopcdata computes the pcdata value in effect at p.
// A PCDATA instruction sets the value in effect at future
// non-PCDATA instructions.
// Since PCDATA instructions have no width in the final code,
// it does not matter which phase we use for the update.
func pctopcdata(ctxt *Link, sym *LSym, oldval int, p *Prog, phase int, arg interface{}) int {
	if phase == 0 || p.As != ctxt.Arch.APCDATA || p.From.Offset != int64(arg.(int)) {
		return oldval
	}
	if int64(int(p.To.Offset)) != p.To.Offset {
		ctxt.Diag("overflow in PCDATA instruction: %P", p)
		log.Fatalf("bad code")
	}
	return int(p.To.Offset)
}

func linkpcln(ctxt *Link, cursym *LSym) {
	var p *Prog
	var pcln *Pcln
	var i int
	var npcdata int
	var nfuncdata int
	var n int
	var havepc []uint32
	var havefunc []uint32
	ctxt.Cursym = cursym
	pcln = new(Pcln)
	cursym.Pcln = pcln
	npcdata = 0
	nfuncdata = 0
	for p = cursym.Text; p != nil; p = p.Link {
		if p.As == ctxt.Arch.APCDATA && p.From.Offset >= int64(npcdata) {
			npcdata = int(p.From.Offset + 1)
		}
		if p.As == ctxt.Arch.AFUNCDATA && p.From.Offset >= int64(nfuncdata) {
			nfuncdata = int(p.From.Offset + 1)
		}
	}
	pcln.Pcdata = make([]Pcdata, npcdata)
	pcln.Pcdata = pcln.Pcdata[:npcdata]
	pcln.Funcdata = make([]*LSym, nfuncdata)
	pcln.Funcdataoff = make([]int64, nfuncdata)
	pcln.Nfuncdata = nfuncdata
	funcpctab(ctxt, &pcln.Pcsp, cursym, "pctospadj", pctospadj, nil)
	funcpctab(ctxt, &pcln.Pcfile, cursym, "pctofile", pctofileline, pcln)
	funcpctab(ctxt, &pcln.Pcline, cursym, "pctoline", pctofileline, nil)
	// tabulate which pc and func data we have.
	n = ((npcdata+31)/32 + (nfuncdata+31)/32)
	havepc = make([]uint32, n)
	havefunc = havepc[(npcdata+31)/32:]
	for p = cursym.Text; p != nil; p = p.Link {
		if p.As == ctxt.Arch.AFUNCDATA {
			if (havefunc[p.From.Offset/32]>>uint64(p.From.Offset%32))&1 != 0 {
				ctxt.Diag("multiple definitions for FUNCDATA $%d", p.From.Offset)
			}
			havefunc[p.From.Offset/32] |= 1 << uint64(p.From.Offset%32)
		}
		if p.As == ctxt.Arch.APCDATA {
			havepc[p.From.Offset/32] |= 1 << uint64(p.From.Offset%32)
		}
	}
	// pcdata.
	for i = 0; i < npcdata; i++ {
		if (havepc[i/32]>>uint(i%32))&1 == 0 {
			continue
		}
		funcpctab(ctxt, &pcln.Pcdata[i], cursym, "pctopcdata", pctopcdata, i)
	}

	// funcdata
	if nfuncdata > 0 {
		for p = cursym.Text; p != nil; p = p.Link {
			if p.As == ctxt.Arch.AFUNCDATA {
				i = int(p.From.Offset)
				pcln.Funcdataoff[i] = p.To.Offset
				if p.To.Typ != ctxt.Arch.D_CONST {
					// TODO: Dedup.
					//funcdata_bytes += p->to.sym->size;
					pcln.Funcdata[i] = p.To.Sym
				}
			}
		}
	}
}

// iteration over encoded pcdata tables.
func getvarint(pp *[]uint8) uint32 {
	var p []uint8
	var shift int
	var v uint32
	v = 0
	p = []uint8(*pp)
	for shift = 0; ; shift += 7 {
		v |= uint32(p[0]&0x7F) << uint(shift)
		tmp7 := p
		p = p[1:]
		if tmp7[0]&0x80 == 0 {
			break
		}
	}
	*pp = p
	return v
}

func pciternext(it *Pciter) {
	var v uint32
	var dv int
	it.pc = it.nextpc
	if it.done != 0 {
		return
	}
	if -cap(it.p) >= -cap(it.d.P[len(it.d.P):]) {
		it.done = 1
		return
	}
	// value delta
	v = getvarint(&it.p)
	if v == 0 && it.start == 0 {
		it.done = 1
		return
	}
	it.start = 0
	dv = int(v>>1) ^ (int(v<<31) >> 31)
	it.value += dv
	// pc delta
	v = getvarint(&it.p)
	it.nextpc = it.pc + v*it.pcscale
}

func pciterinit(ctxt *Link, it *Pciter, d *Pcdata) {
	it.d = *d
	it.p = it.d.P
	it.pc = 0
	it.nextpc = 0
	it.value = -1
	it.start = 1
	it.done = 0
	it.pcscale = ctxt.Arch.Minlc
	pciternext(it)
}