ristretto_vm 0.32.1

Java Virtual Machine
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95

//! # JVM Bytecode Instruction Implementation
//!
//! This module implements the Java Virtual Machine instruction set as defined in the JVM
//! specification. Each submodule contains implementations for a specific category of bytecode
//! instructions.
//!
//! ## Instruction Categories
//!
//! * `array` - Array manipulation instructions (e.g., `aaload`, `aastore`)
//! * `branch` - Branching and control flow instructions (e.g., `if_icmpeq`, `goto`)
//! * `byte` - Byte manipulation instructions
//! * `char` - Character manipulation instructions
//! * `convert` - Type conversion instructions (e.g., `i2l`, `f2d`)
//! * `debug` - Debugging-related instructions
//! * `double` - Double-precision floating point instructions
//! * `exception` - Exception handling instructions (e.g., `athrow`)
//! * `field` - Field access instructions (e.g., `getfield`, `putfield`)
//! * `float` - Floating point instructions
//! * `integer` - Integer arithmetic and logic instructions
//! * `invokedynamic` - Dynamic method invocation instructions
//! * `invokeinterface` - Interface method invocation instructions
//! * `invokespecial` - Special method invocation instructions (e.g., constructors)
//! * `invokestatic` - Static method invocation instructions
//! * `invokevirtual` - Virtual method invocation instructions
//! * `ldc` - Constant loading instructions
//! * `long` - Long integer instructions
//! * `monitor` - Monitor-related instructions for synchronization
//! * `nop` - No-operation instruction
//! * `object` - Object manipulation instructions
//! * `push` - Stack value pushing instructions
//! * `short` - Short integer instructions
//! * `stack` - Stack manipulation instructions (e.g., `dup`, `swap`)
//! * `static` - Static field instructions
//! * `wide` - Wide instruction prefix for accessing local variables with wider indices
//!
//! Each instruction implementation follows the JVM specification regarding operand stack
//! manipulation, control flow, and runtime behavior.

mod array;
mod branch;
mod byte;
mod char;
mod convert;
mod debug;
mod double;
mod exception;
pub(crate) use exception::convert_error_to_throwable;
mod field;
mod float;
mod integer;
mod invokedynamic;
mod invokeinterface;
mod invokespecial;
mod invokestatic;
mod invokevirtual;
mod ldc;
mod long;
mod method_resolver;
mod module_access;
mod monitor;
mod nop;
mod object;
mod push;
mod short;
mod stack;
mod r#static;
mod wide;

pub(crate) use array::*;
pub(crate) use branch::*;
pub(crate) use byte::*;
pub(crate) use char::*;
pub(crate) use convert::*;
pub(crate) use debug::*;
pub(crate) use double::*;
pub(crate) use exception::*;
pub(crate) use field::*;
pub(crate) use float::*;
pub(crate) use integer::*;
pub(crate) use invokedynamic::*;
pub(crate) use invokeinterface::*;
pub(crate) use invokespecial::*;
pub(crate) use invokestatic::*;
pub(crate) use invokevirtual::*;
pub(crate) use ldc::*;
pub(crate) use long::*;
pub(crate) use method_resolver::{lookup_method, resolve_method_ref};
pub(crate) use monitor::*;
pub(crate) use nop::*;
pub(crate) use object::*;
pub(crate) use push::*;
pub(crate) use short::*;
pub(crate) use stack::*;
pub(crate) use r#static::*;
pub(crate) use wide::*;