New Opcode Proposal 2: `L / R` Structured Skip Region

Structured Skip Regions via L / R Opcodes

Abstract

This introduces two new EVM opcodes, L (Left delimiter) and R (Right delimiter), which define structured skip regions in bytecode.

When executed, L causes the EVM to skip forward to its matching R without executing the enclosed bytes. These regions allow contracts to embed non-executable structured data directly inside bytecode while preserving deterministic execution.

Motivation

EVM bytecode currently has no native way to distinguish:

• Executable instructions
• Embedded metadata
• Compiler tables
• Structured constants
• Alternative code paths meant only for off-chain tools

All bytes are treated as potentially executable instructions, and the only way to skip code is through dynamic jumps.

This leads to problems:

• Compilers cannot safely embed structured data in bytecode
• Static tools must conservatively treat all bytes as executable
• Bytecode cannot carry rich internal structure without risking accidental execution
• Control-flow must be expressed using unstructured jumps

We propose structured skip regions that behave like non-executed islands inside bytecode.

These regions allow bytecode to safely contain:

• Lookup tables
• Jump tables
• Type metadata
• ABI-like internal descriptors
• Compiler hints
• Future extension payloads

without affecting execution.

Specification

New Opcodes

Semantics

1. L — Skip Forward to Matching R

When the EVM executes opcode L:

• It enters skip mode
• It scans forward in bytecode to find the matching R
• All bytes in between are ignored and never executed
• Nested L/R pairs must be balanced

Matching Algorithm

depth = 1pc = pc + 1while depth > 0:opcode = code[pc]if opcode == L:depth += 1else if opcode == R:depth -= 1pc += 1

2. R — Structural Delimiter

Execution resumes at the first opcode after the matching R.

If no matching R is found → exceptional halt.

Structural Rules

1. Regions Are Non-Executable

Bytes inside an L … R region:

• Must never be executed
• Are treated as opaque payload
• May contain arbitrary byte values, including invalid opcodes

2. Jumping Into or Out of Regions is not forbidden

It is valid to:

• JUMP or JUMPI to a location inside a skip region
• Jump from inside a region to outside

3. Nesting Is Allowed

Skip regions may be nested:

L<data or metadata>L<more data>RR

The matching algorithm ensures correct pairing.

Gas Costs

Clients MAY preprocess bytecode to map matching pairs, allowing L to execute in constant time.

Rationale

Bytecode as a Structured Container

This proposal lets contracts treat bytecode not just as instructions, but as a container format.

With L/R, bytecode can safely include:

All without risking accidental execution.

Why Not Just Use JUMP?

Using JUMP to skip over data:

• Requires dynamic control flow
• Leaves the skipped bytes syntactically executable
• Makes static analysis ambiguous
• Cannot safely contain arbitrary byte patterns

L/R instead create explicit non-executable regions, similar to data sections in traditional binaries.

Why Not Reuse JUMPDEST?

JUMPDEST marks valid jump targets but does not mark non-executable regions.
We need the opposite: a way to declare “this is not code.”

Backwards Compatibility

Fully backward compatible:

• Existing contracts contain no L or R
• Old bytecode behavior unchanged
• New semantics apply only when opcodes are present

Example: Embedding a Data Table

PUSH1 0x00SSTOREL0x12 0x34 0x56 0x780x9a 0xbc 0xde 0xf0RPUSH1 0x01SSTORE

The bytes inside L … R are never executed and can be read by off-chain tools or by copying code via EXTCODECOPY.

Conclusion

L and R introduce structured non-executable regions to the EVM, enabling bytecode to function as a hybrid of code and structured data.

This:

• Improves analyzability
• Enables safer compiler-generated metadata
• Allows dense in-bytecode data structures
• Preserves full backward compatibility
• Requires minimal changes to the execution model

A small opcode addition turns EVM bytecode into a self-describing, structured artifact, not just a flat instruction stream.