1 files changed, 43 insertions, 14 deletions
diff --git a/core/vm/analysis.go b/core/vm/analysis.go
index d5f048d1d..f9c4298d3 100644
--- a/core/vm/analysis.go
+++ b/core/vm/analysis.go
@@ -25,7 +25,7 @@ import (
 // destinations stores one map per contract (keyed by hash of code).
 // The maps contain an entry for each location of a JUMPDEST
 // instruction.
-type destinations map[common.Hash][]byte
+type destinations map[common.Hash]bitvec
 
 // has checks whether code has a JUMPDEST at dest.
 func (d destinations) has(codehash common.Hash, code []byte, dest *big.Int) bool {
@@ -38,24 +38,53 @@ func (d destinations) has(codehash common.Hash, code []byte, dest *big.Int) bool
 
 	m, analysed := d[codehash]
 	if !analysed {
-		m = jumpdests(code)
+		m = codeBitmap(code)
 		d[codehash] = m
 	}
-	return (m[udest/8] & (1 << (udest % 8))) != 0
+	return OpCode(code[udest]) == JUMPDEST && m.codeSegment(udest)
 }
 
-// jumpdests creates a map that contains an entry for each
-// PC location that is a JUMPDEST instruction.
-func jumpdests(code []byte) []byte {
-	m := make([]byte, len(code)/8+1)
-	for pc := uint64(0); pc < uint64(len(code)); pc++ {
+// bitvec is a bit vector which maps bytes in a program.
+// An unset bit means the byte is an opcode, a set bit means
+// it's data (i.e. argument of PUSHxx).
+type bitvec []byte
+
+func (bits *bitvec) set(pos uint64) {
+	(*bits)[pos/8] |= 0x80 >> (pos % 8)
+}
+func (bits *bitvec) set8(pos uint64) {
+	(*bits)[pos/8] |= 0xFF >> (pos % 8)
+	(*bits)[pos/8+1] |= ^(0xFF >> (pos % 8))
+}
+
+// codeSegment checks if the position is in a code segment.
+func (bits *bitvec) codeSegment(pos uint64) bool {
+	return ((*bits)[pos/8] & (0x80 >> (pos % 8))) == 0
+}
+
+// codeBitmap collects data locations in code.
+func codeBitmap(code []byte) bitvec {
+	// The bitmap is 4 bytes longer than necessary, in case the code
+	// ends with a PUSH32, the algorithm will push zeroes onto the
+	// bitvector outside the bounds of the actual code.
+	bits := make(bitvec, len(code)/8+1+4)
+	for pc := uint64(0); pc < uint64(len(code)); {
 		op := OpCode(code[pc])
-		if op == JUMPDEST {
-			m[pc/8] |= 1 << (pc % 8)
-		} else if op >= PUSH1 && op <= PUSH32 {
-			a := uint64(op) - uint64(PUSH1) + 1
-			pc += a
+
+		if op >= PUSH1 && op <= PUSH32 {
+			numbits := op - PUSH1 + 1
+			pc++
+			for ; numbits >= 8; numbits -= 8 {
+				bits.set8(pc) // 8
+				pc += 8
+			}
+			for ; numbits > 0; numbits-- {
+				bits.set(pc)
+				pc++
+			}
+		} else {
+			pc++
 		}
 	}
-	return m
+	return bits
 }