Enum Instruction

#[repr(u8)]
pub enum Instruction {
    ImportName {
        idx: Arg<u32>,
    },
    ImportNameless,
    ImportStar,
    ImportFrom {
        idx: Arg<u32>,
    },
    LoadFast(Arg<u32>),
    LoadNameAny(Arg<u32>),
    LoadGlobal(Arg<u32>),
    LoadDeref(Arg<u32>),
    LoadClassDeref(Arg<u32>),
    StoreFast(Arg<u32>),
    StoreLocal(Arg<u32>),
    StoreGlobal(Arg<u32>),
    StoreDeref(Arg<u32>),
    DeleteFast(Arg<u32>),
    DeleteLocal(Arg<u32>),
    DeleteGlobal(Arg<u32>),
    DeleteDeref(Arg<u32>),
    LoadClosure(Arg<u32>),
    Subscript,
    StoreSubscript,
    DeleteSubscript,
    StoreAttr {
        idx: Arg<u32>,
    },
    DeleteAttr {
        idx: Arg<u32>,
    },
    LoadConst {
        idx: Arg<u32>,
    },
    UnaryOperation {
        op: Arg<UnaryOperator>,
    },
    BinaryOperation {
        op: Arg<BinaryOperator>,
    },
    BinaryOperationInplace {
        op: Arg<BinaryOperator>,
    },
    LoadAttr {
        idx: Arg<u32>,
    },
    TestOperation {
        op: Arg<TestOperator>,
    },
    CompareOperation {
        op: Arg<ComparisonOperator>,
    },
    Pop,
    Rotate2,
    Rotate3,
    Duplicate,
    Duplicate2,
    GetIter,
    Continue {
        target: Arg<Label>,
    },
    Break {
        target: Arg<Label>,
    },
    Jump {
        target: Arg<Label>,
    },
    JumpIfTrue {
        target: Arg<Label>,
    },
    JumpIfFalse {
        target: Arg<Label>,
    },
    JumpIfTrueOrPop {
        target: Arg<Label>,
    },
    JumpIfFalseOrPop {
        target: Arg<Label>,
    },
    MakeFunction(Arg<MakeFunctionFlags>),
    CallFunctionPositional {
        nargs: Arg<u32>,
    },
    CallFunctionKeyword {
        nargs: Arg<u32>,
    },
    CallFunctionEx {
        has_kwargs: Arg<bool>,
    },
    LoadMethod {
        idx: Arg<u32>,
    },
    CallMethodPositional {
        nargs: Arg<u32>,
    },
    CallMethodKeyword {
        nargs: Arg<u32>,
    },
    CallMethodEx {
        has_kwargs: Arg<bool>,
    },
    ForIter {
        target: Arg<Label>,
    },
    ReturnValue,
    ReturnConst {
        idx: Arg<u32>,
    },
    YieldValue,
    YieldFrom,
    SetupAnnotation,
    SetupLoop,
    SetupFinally {
        handler: Arg<Label>,
    },
    EnterFinally,
    EndFinally,
    SetupExcept {
        handler: Arg<Label>,
    },
    SetupWith {
        end: Arg<Label>,
    },
    WithCleanupStart,
    WithCleanupFinish,
    PopBlock,
    Raise {
        kind: Arg<RaiseKind>,
    },
    BuildString {
        size: Arg<u32>,
    },
    BuildTuple {
        size: Arg<u32>,
    },
    BuildTupleUnpack {
        size: Arg<u32>,
    },
    BuildList {
        size: Arg<u32>,
    },
    BuildListUnpack {
        size: Arg<u32>,
    },
    BuildSet {
        size: Arg<u32>,
    },
    BuildSetUnpack {
        size: Arg<u32>,
    },
    BuildMap {
        size: Arg<u32>,
    },
    BuildMapForCall {
        size: Arg<u32>,
    },
    DictUpdate,
    BuildSlice {
        step: Arg<bool>,
    },
    ListAppend {
        i: Arg<u32>,
    },
    SetAdd {
        i: Arg<u32>,
    },
    MapAdd {
        i: Arg<u32>,
    },
    PrintExpr,
    LoadBuildClass,
    UnpackSequence {
        size: Arg<u32>,
    },
    UnpackEx {
        args: Arg<UnpackExArgs>,
    },
    FormatValue {
        conversion: Arg<ConversionFlag>,
    },
    PopException,
    Reverse {
        amount: Arg<u32>,
    },
    GetAwaitable,
    BeforeAsyncWith,
    SetupAsyncWith {
        end: Arg<Label>,
    },
    GetAIter,
    GetANext,
    EndAsyncFor,
    ExtendedArg,
    TypeVar,
    TypeVarWithBound,
    TypeVarWithConstraint,
    TypeAlias,
}

A Single bytecode instruction.

Variants

ImportName

Importing by name

Fields

idx: Arg<u32>

ImportNameless

Importing without name

ImportStar

Import *

ImportFrom

from … import …

Fields

idx: Arg<u32>

LoadFast(Arg<u32>)

LoadNameAny(Arg<u32>)

LoadGlobal(Arg<u32>)

LoadDeref(Arg<u32>)

LoadClassDeref(Arg<u32>)

StoreFast(Arg<u32>)

StoreLocal(Arg<u32>)

StoreGlobal(Arg<u32>)

StoreDeref(Arg<u32>)

DeleteFast(Arg<u32>)

DeleteLocal(Arg<u32>)

DeleteGlobal(Arg<u32>)

DeleteDeref(Arg<u32>)

LoadClosure(Arg<u32>)

Subscript

StoreSubscript

DeleteSubscript

StoreAttr

Fields

idx: Arg<u32>

DeleteAttr

Fields

idx: Arg<u32>

LoadConst

Fields

idx: Arg<u32>

index into constants vec

UnaryOperation

Fields

op: Arg<UnaryOperator>

BinaryOperation

Fields

op: Arg<BinaryOperator>

BinaryOperationInplace

Fields

op: Arg<BinaryOperator>

LoadAttr

Fields

idx: Arg<u32>

TestOperation

Fields

op: Arg<TestOperator>

CompareOperation

Fields

op: Arg<ComparisonOperator>

Pop

Rotate2

Rotate3

Duplicate

Duplicate2

GetIter

Continue

Fields

target: Arg<Label>

Break

Fields

target: Arg<Label>

Jump

Fields

target: Arg<Label>

JumpIfTrue

Pop the top of the stack, and jump if this value is true.

Fields

target: Arg<Label>

JumpIfFalse

Pop the top of the stack, and jump if this value is false.

Fields

target: Arg<Label>

JumpIfTrueOrPop

Peek at the top of the stack, and jump if this value is true. Otherwise, pop top of stack.

Fields

target: Arg<Label>

JumpIfFalseOrPop

Peek at the top of the stack, and jump if this value is false. Otherwise, pop top of stack.

Fields

target: Arg<Label>

MakeFunction(Arg<MakeFunctionFlags>)

CallFunctionPositional

Fields

nargs: Arg<u32>

CallFunctionKeyword

Fields

nargs: Arg<u32>

CallFunctionEx

Fields

has_kwargs: Arg<bool>

LoadMethod

Fields

idx: Arg<u32>

CallMethodPositional

Fields

nargs: Arg<u32>

CallMethodKeyword

Fields

nargs: Arg<u32>

CallMethodEx

Fields

has_kwargs: Arg<bool>

ForIter

Fields

target: Arg<Label>

ReturnValue

ReturnConst

Fields

idx: Arg<u32>

YieldValue

YieldFrom

SetupAnnotation

SetupLoop

SetupFinally

Setup a finally handler, which will be called whenever one of this events occurs:

• the block is popped
• the function returns
• an exception is returned

Fields

handler: Arg<Label>

EnterFinally

Enter a finally block, without returning, excepting, just because we are there.

EndFinally

Marker bytecode for the end of a finally sequence. When this bytecode is executed, the eval loop does one of those things:

• Continue at a certain bytecode position
• Propagate the exception
• Return from a function
• Do nothing at all, just continue

SetupExcept

Fields

handler: Arg<Label>

SetupWith

Fields

end: Arg<Label>

WithCleanupStart

WithCleanupFinish

PopBlock

Raise

Fields

kind: Arg<RaiseKind>

BuildString

Fields

size: Arg<u32>

BuildTuple

Fields

size: Arg<u32>

BuildTupleUnpack

Fields

size: Arg<u32>

BuildList

Fields

size: Arg<u32>

BuildListUnpack

Fields

size: Arg<u32>

BuildSet

Fields

size: Arg<u32>

BuildSetUnpack

Fields

size: Arg<u32>

BuildMap

Fields

size: Arg<u32>

BuildMapForCall

Fields

size: Arg<u32>

DictUpdate

BuildSlice

Fields

step: Arg<bool>

whether build a slice with a third step argument

ListAppend

Fields

i: Arg<u32>

SetAdd

Fields

i: Arg<u32>

MapAdd

Fields

i: Arg<u32>

PrintExpr

LoadBuildClass

UnpackSequence

Fields

size: Arg<u32>

UnpackEx

Fields

args: Arg<UnpackExArgs>

FormatValue

Fields

conversion: Arg<ConversionFlag>

PopException

Reverse

Fields

amount: Arg<u32>

GetAwaitable

BeforeAsyncWith

SetupAsyncWith

Fields

end: Arg<Label>

GetAIter

GetANext

EndAsyncFor

ExtendedArg

TypeVar

TypeVarWithBound

TypeVarWithConstraint

TypeAlias

Implementations

impl Instruction

pub fn label_arg(&self) -> Option<Arg<Label>>

Gets the label stored inside this instruction, if it exists

pub fn unconditional_branch(&self) -> bool

Whether this is an unconditional branching

Examples

use rustpython_compiler_core::bytecode::{Arg, Instruction};
let jump_inst = Instruction::Jump { target: Arg::marker() };
assert!(jump_inst.unconditional_branch())

pub fn stack_effect(&self, arg: OpArg, jump: bool) -> i32

What effect this instruction has on the stack

Examples

use rustpython_compiler_core::bytecode::{Arg, Instruction, Label, UnaryOperator};
let (target, jump_arg) = Arg::new(Label(0xF));
let jump_instruction = Instruction::Jump { target };
let (op, invert_arg) = Arg::new(UnaryOperator::Invert);
let invert_instruction = Instruction::UnaryOperation { op };
assert_eq!(jump_instruction.stack_effect(jump_arg, true), 0);
assert_eq!(invert_instruction.stack_effect(invert_arg, false), 0);

pub fn display<'a>( &'a self, arg: OpArg, ctx: &'a impl InstrDisplayContext, ) -> impl Display + 'a

Trait Implementations

impl Clone for Instruction

fn clone(&self) -> Instruction

Returns a copy of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for Instruction

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

Formats the value using the given formatter.

impl PartialEq for Instruction

fn eq(&self, other: &Instruction) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl TryFrom<u8> for Instruction

type Error = MarshalError

The type returned in the event of a conversion error.

fn try_from(value: u8) -> Result<Instruction, MarshalError>

Performs the conversion.

impl Copy for Instruction

impl Eq for Instruction

impl StructuralPartialEq for Instruction