AVM: Switch opcode

data/transactions/logic/assembler.go

@@ -48,10 +48,13 @@ type Writer interface {
 type labelReference struct {
 	sourceLine int
 
-	// position of the opcode start that refers to the label
+	// position of the label reference
 	position int
 
 	label string
+
+	// ending positions of the opcode containing the label reference.
+	offsetPosition int
 }
 
 type constReference interface {
@@ -346,8 +349,8 @@ func (ops *OpStream) recordSourceLine() {
 }
 
 // referToLabel records an opcode label reference to resolve later
-func (ops *OpStream) referToLabel(pc int, label string) {
-	ops.labelReferences = append(ops.labelReferences, labelReference{ops.sourceLine, pc, label})
+func (ops *OpStream) referToLabel(pc int, label string, offsetPosition int) {
+	ops.labelReferences = append(ops.labelReferences, labelReference{ops.sourceLine, pc, label, offsetPosition})
 }
 
 type refineFunc func(pgm *ProgramKnowledge, immediates []string) (StackTypes, StackTypes)
@@ -510,7 +513,7 @@ func asmInt(ops *OpStream, spec *OpSpec, args []string) error {
 		ops.IntLiteral(i)
 		return nil
 	}
-	// check OnCompetion constants
+	// check OnCompletion constants
 	oc, isOCStr := onCompletionMap[args[0]]
 	if isOCStr {
 		ops.IntLiteral(oc)
@@ -903,14 +906,38 @@ func asmBranch(ops *OpStream, spec *OpSpec, args []string) error {
 		return ops.error("branch operation needs label argument")
 	}
 
-	ops.referToLabel(ops.pending.Len(), args[0])
+	ops.referToLabel(ops.pending.Len()+1, args[0], ops.pending.Len()+spec.Size)
 	ops.pending.WriteByte(spec.Opcode)
 	// zero bytes will get replaced with actual offset in resolveLabels()
 	ops.pending.WriteByte(0)
 	ops.pending.WriteByte(0)
 	return nil
 }
 
+func asmSwitch(ops *OpStream, spec *OpSpec, args []string) error {
+	numOffsets, err := strconv.ParseUint(args[0], 0, 64)
+	if err != nil {
+		return err
+	}
+
+	if len(args)-1 != int(numOffsets) {
+		return ops.errorf("switch operation requires %d labels but contains %d", numOffsets, len(args)-1)
+	}
+
+	ops.pending.WriteByte(spec.Opcode)
+	var scratch [binary.MaxVarintLen64]byte
+	vlen := binary.PutUvarint(scratch[:], numOffsets)
+	ops.pending.Write(scratch[:vlen])
+	opEndPos := ops.pending.Len() + 2*int(numOffsets)
+	for i := 1; i <= int(numOffsets); i++ {
+		ops.referToLabel(ops.pending.Len(), args[i], opEndPos)
+		// zero bytes will get replaced with actual offset in resolveLabels()
+		ops.pending.WriteByte(0)
+		ops.pending.WriteByte(0)
+	}
+	return nil
+}
+
 func asmSubstring(ops *OpStream, spec *OpSpec, args []string) error {
 	err := asmDefault(ops, spec, args)
 	if err != nil {
@@ -1815,19 +1842,20 @@ func (ops *OpStream) resolveLabels() {
 			reported[lr.label] = true
 			continue
 		}
-		// all branch instructions (currently) are opcode byte and 2 offset bytes, and the destination is relative to the next pc as if the branch was a no-op
-		naturalPc := lr.position + 3
-		if ops.Version < backBranchEnabledVersion && dest < naturalPc {
+
+		// All branch targets are encoded as 2 offset bytes. The destination is relative to the end of the
+		// instruction they appear in, which is available in lr.offsetPostion
+		if ops.Version < backBranchEnabledVersion && dest < lr.offsetPosition {
 			ops.errorf("label %#v is a back reference, back jump support was introduced in v4", lr.label)
 			continue
 		}
-		jump := dest - naturalPc
+		jump := dest - lr.offsetPosition
 		if jump > 0x7fff {
 			ops.errorf("label %#v is too far away", lr.label)
 			continue
 		}
-		raw[lr.position+1] = uint8(jump >> 8)
-		raw[lr.position+2] = uint8(jump & 0x0ff)
+		raw[lr.position] = uint8(jump >> 8)
+		raw[lr.position+1] = uint8(jump & 0x0ff)
 	}
 	ops.pending = *bytes.NewBuffer(raw)
 	ops.sourceLine = saved
@@ -2061,6 +2089,7 @@ func (ops *OpStream) optimizeConstants(refs []constReference, constBlock []inter
 		for i := range ops.labelReferences {
 			if ops.labelReferences[i].position > position {
 				ops.labelReferences[i].position += positionDelta
+				ops.labelReferences[i].offsetPosition += positionDelta
 			}
 		}
 
@@ -2297,11 +2326,8 @@ func disassemble(dis *disassembleState, spec *OpSpec) (string, error) {
 
 			pc++
 		case immLabel:
-			offset := (uint(dis.program[pc]) << 8) | uint(dis.program[pc+1])
-			target := int(offset) + pc + 2
-			if target > 0xffff {
-				target -= 0x10000
-			}
+			offset := decodeBranchOffset(dis.program, pc)
+			target := offset + pc + 2
 			var label string
 			if dis.numericTargets {
 				label = fmt.Sprintf("%d", target)
@@ -2363,6 +2389,31 @@ func disassemble(dis *disassembleState, spec *OpSpec) (string, error) {
 				out += fmt.Sprintf("0x%s", hex.EncodeToString(bv))
 			}
 			pc = nextpc
+		case immLabels:
+			targets, nextpc, err := parseSwitch(dis.program, pc)
+			if err != nil {
+				return "", err
+			}
+
+			var labels []string
+			for _, target := range targets {
+				var label string
+				if dis.numericTargets {
+					label = fmt.Sprintf("%d", target)
+				} else {
+					if known, ok := dis.pendingLabels[target]; ok {
+						label = known
+					} else {
+						dis.labelCount++
+						label = fmt.Sprintf("label%d", dis.labelCount)
+						dis.putLabel(label, target)
+					}
+				}
+				labels = append(labels, label)
+			}
+			out += strconv.Itoa(len(targets)) + " "
+			out += strings.Join(labels, " ")
+			pc = nextpc
 		default:
 			return "", fmt.Errorf("unknown immKind %d", imm.kind)
 		}
@@ -2516,6 +2567,29 @@ func checkByteConstBlock(cx *EvalContext) error {
 	return nil
 }
 
+func parseSwitch(program []byte, pos int) (targets []int, nextpc int, err error) {
+	numOffsets, bytesUsed := binary.Uvarint(program[pos:])
+	if bytesUsed <= 0 {
+		err = fmt.Errorf("could not decode switch target list size at pc=%d", pos)
+		return
+	}
+	pos += bytesUsed
+	if numOffsets > uint64(len(program)) {
+		err = errTooManyItems
+		return
+	}
+
+	end := pos + int(2*numOffsets) // end of op: offset is applied to this position
+	for i := 0; i < int(numOffsets); i++ {
+		offset := decodeBranchOffset(program, pos)
+		target := int(offset) + int(end)
+		targets = append(targets, target)
+		pos += 2
+	}
+	nextpc = pos
+	return
+}
+
 func allPrintableASCII(bytes []byte) bool {
 	for _, b := range bytes {
 		if b < 32 || b > 126 {

data/transactions/logic/assembler_test.go

@@ -18,6 +18,7 @@ package logic
 
 import (
 	"bytes"
+	"encoding/binary"
 	"encoding/hex"
 	"fmt"
 	"strings"
@@ -394,7 +395,13 @@ pushint 1
 replace3
 `
 
-const v8Nonsense = v7Nonsense + pairingNonsense
+const v8Nonsense = v7Nonsense + pairingNonsense + `
+switch_label0:
+pushint 1
+switchi 2 switch_label0 switch_label1
+switch_label1:
+pushint 1
+`
 
 const v6Compiled = "2004010002b7a60c26050242420c68656c6c6f20776f726c6421070123456789abcd208dae2087fbba51304eb02b91f656948397a7946390e8cb70fc9ea4d95f92251d047465737400320032013202320380021234292929292b0431003101310231043105310731083109310a310b310c310d310e310f3111311231133114311533000033000133000233000433000533000733000833000933000a33000b33000c33000d33000e33000f3300113300123300133300143300152d2e01022581f8acd19181cf959a1281f8acd19181cf951a81f8acd19181cf1581f8acd191810f082209240a220b230c240d250e230f23102311231223132314181b1c28171615400003290349483403350222231d4a484848482b50512a632223524100034200004322602261222704634848222862482864286548482228246628226723286828692322700048482371004848361c0037001a0031183119311b311d311e311f312023221e312131223123312431253126312731283129312a312b312c312d312e312f447825225314225427042455220824564c4d4b0222382124391c0081e80780046a6f686e2281d00f23241f880003420001892224902291922494249593a0a1a2a3a4a5a6a7a8a9aaabacadae24af3a00003b003c003d816472064e014f012a57000823810858235b235a2359b03139330039b1b200b322c01a23c1001a2323c21a23c3233e233f8120af06002a494905002a49490700b53a03b6b7043cb8033a0c2349c42a9631007300810881088120978101c53a8101c6003a"
 
@@ -403,7 +410,7 @@ const randomnessCompiled = "81ffff03d101d000"
 const v7Compiled = v6Compiled + "5e005f018120af060180070123456789abcd49490501988003012345494984" +
 	randomnessCompiled + "800243218001775c0280018881015d"
 
-const v8Compiled = v7Compiled + pairingCompiled
+const v8Compiled = v7Compiled + pairingCompiled + "8101e002fff800008101"
 
 var nonsense = map[uint64]string{
 	1: v1Nonsense,
@@ -1551,6 +1558,7 @@ txna ClearStateProgramPages 0
 	}
 	ops := testProg(t, text, AssemblerMaxVersion)
 	t2, err := Disassemble(ops.Program)
+	fmt.Println(t2)
 	require.Equal(t, text, t2)
 	require.NoError(t, err)
 }
@@ -2759,3 +2767,68 @@ func TestSemiColon(t *testing.T) {
 		`byte "test;this";;;pop;`,
 	)
 }
+
+func TestAssembleSwitch(t *testing.T) {
+	partitiontest.PartitionTest(t)
+	t.Parallel()
+
+	// fail when wrong number of targets are present
+	source := `
+	pushint 1
+	switchi 2 label1 label2 label3
+	label1:
+	label2:
+	label3:
+	`
+	testProg(t, source, 8, NewExpect(3, "switch operation requires 2 labels but contains 3"))
+
+	// fail when target doesn't correspond to existing label
+	source = `
+	pushint 1
+	switchi 2 label1 label2
+	label1:
+	`
+	testProg(t, source, 8, NewExpect(3, "reference to undefined label \"label2\""))
+
+	// confirm size of varuint list size
+	source = `
+	pushint 1
+	switchi 2 label1 label2
+	label1:
+	label2:
+	`
+	ops, err := AssembleStringWithVersion(source, 8)
+	require.NoError(t, err)
+	val, bytesUsed := binary.Uvarint(ops.Program[4:])
+	require.Equal(t, uint64(2), val)
+	require.Equal(t, 1, bytesUsed)
+
+	var labelReferences []string
+	for i := 0; i < (1 << 9); i++ {
+		labelReferences = append(labelReferences, fmt.Sprintf("label%d", i))
+	}
+
+	var labels []string
+	for i := 0; i < (1 << 9); i++ {
+		labels = append(labels, fmt.Sprintf("label%d:", i))
+	}
+
+	source = fmt.Sprintf(`
+	pushint 1
+	switchi %d %s
+	%s
+	`, (1 << 9), strings.Join(labelReferences, " "), strings.Join(labels, "\n"))
+	ops, err = AssembleStringWithVersion(source, 8)
+	require.NoError(t, err)
+	val, bytesUsed = binary.Uvarint(ops.Program[4:])
+	require.Equal(t, uint64(1<<9), val)
+	require.Equal(t, 2, bytesUsed)
+
+	// allow duplicate label reference
+	source = `
+	pushint 1
+	switchi 2 label1 label1
+	label1:
+	`
+	testProg(t, source, 8)
+}

data/transactions/logic/doc.go

@@ -193,6 +193,8 @@ var opDocByName = map[string]string{
 
 	"vrf_verify": "Verify the proof B of message A against pubkey C. Returns vrf output and verification flag.",
 	"block":      "field F of block A. Fail unless A falls between txn.LastValid-1002 and txn.FirstValid (exclusive)",
+
+	"switchi": "branch to target at index A. Fail if index A is out of bounds.",
 }
 
 // OpDoc returns a description of the op
@@ -261,6 +263,8 @@ var opcodeImmediateNotes = map[string]string{
 
 	"vrf_verify": "{uint8 parameters index}",
 	"block":      "{uint8 block field}",
+
+	"switchi": "{varuint length} [{int16 branch offset, big-endian}, ...]",
 }
 
 // OpImmediateNote returns a short string about immediate data which follows the op byte
@@ -339,7 +343,7 @@ var OpGroups = map[string][]string{
 	"Byte Array Arithmetic":   {"b+", "b-", "b/", "b*", "b<", "b>", "b<=", "b>=", "b==", "b!=", "b%", "bsqrt"},
 	"Byte Array Logic":        {"b|", "b&", "b^", "b~"},
 	"Loading Values":          {"intcblock", "intc", "intc_0", "intc_1", "intc_2", "intc_3", "pushint", "bytecblock", "bytec", "bytec_0", "bytec_1", "bytec_2", "bytec_3", "pushbytes", "bzero", "arg", "arg_0", "arg_1", "arg_2", "arg_3", "args", "txn", "gtxn", "txna", "txnas", "gtxna", "gtxnas", "gtxns", "gtxnsa", "gtxnsas", "global", "load", "loads", "store", "stores", "gload", "gloads", "gloadss", "gaid", "gaids"},
-	"Flow Control":            {"err", "bnz", "bz", "b", "return", "pop", "dup", "dup2", "dig", "cover", "uncover", "swap", "select", "assert", "callsub", "retsub"},
+	"Flow Control":            {"err", "bnz", "bz", "b", "return", "pop", "dup", "dup2", "dig", "cover", "uncover", "swap", "select", "assert", "callsub", "retsub", "switchi"},
 	"State Access":            {"balance", "min_balance", "app_opted_in", "app_local_get", "app_local_get_ex", "app_global_get", "app_global_get_ex", "app_local_put", "app_global_put", "app_local_del", "app_global_del", "asset_holding_get", "asset_params_get", "app_params_get", "acct_params_get", "log", "block"},
 	"Inner Transactions":      {"itxn_begin", "itxn_next", "itxn_field", "itxn_submit", "itxn", "itxna", "itxnas", "gitxn", "gitxna", "gitxnas"},
 }