loads

package
v0.0.0-...-26bd4cb Latest Latest
Warning

This package is not in the latest version of its module.

Go to latest
Published: Dec 28, 2019 License: MIT Imports: 3 Imported by: 0

Documentation

Index

Constants

This section is empty.

Variables

This section is empty.

Functions

func NotNull

func NotNull(ref heap.Object)

Types

type AALoad

type AALoad struct {
	base.NoOperandsInstruction
}

func (*AALoad) Execute

func (this *AALoad) Execute(frame *rtda.Frame)

type ALoad

type ALoad struct {
	base.Index8Instruction
}

指令定义来源 The Java® Virtual Machine Specification https://docs.oracle.com/javase/specs/jvms/se8/jvms8.pdf aload Page.371

格式: aload [index] 字节: 0x19 0x01

指令样例     8进制表示     指令含义
aload 1     0x19 0x01    将当前帧(方法)本地变量表下标为 1 的对象引用推到操作数栈

操作: 从当前帧(方法)本地变量表的 index 下标处加载对象引用到操作数栈 描述: index 是一个 无符号的单字节整数 PS: aload 类指令无法加载 returnAddress 类型的值到操作数栈,和 astore 指令的这种不对称是有意设计的

func (*ALoad) Execute

func (this *ALoad) Execute(frame *rtda.Frame)

type ALoad0

type ALoad0 struct {
	base.NoOperandsInstruction
}

指令定义来源 The Java® Virtual Machine Specification https://docs.oracle.com/javase/specs/jvms/se8/jvms8.pdf aload_<n> Page.372

格式: aload_<n> 字节:

指令样例     8进制表示   指令含义
aload_0     0x2a       将当前帧(方法)本地变量表下标为 0 的对象引用推到操作数栈
aload_1     0x2b       将当前帧(方法)本地变量表下标为 1 的对象引用推到操作数栈
aload_2     0x2c       将当前帧(方法)本地变量表下标为 2 的对象引用推到操作数栈
aload_3     0x2d       将当前帧(方法)本地变量表下标为 3 的对象引用推到操作数栈

操作: 从当前帧(方法)本地变量表的 <n> 下标处加载对象引用到操作数栈 描述:

func (*ALoad0) Execute

func (this *ALoad0) Execute(frame *rtda.Frame)

type ALoad1

type ALoad1 struct {
	base.NoOperandsInstruction
}

func (*ALoad1) Execute

func (this *ALoad1) Execute(frame *rtda.Frame)

type ALoad2

type ALoad2 struct {
	base.NoOperandsInstruction
}

func (*ALoad2) Execute

func (this *ALoad2) Execute(frame *rtda.Frame)

type ALoad3

type ALoad3 struct {
	base.NoOperandsInstruction
}

func (*ALoad3) Execute

func (this *ALoad3) Execute(frame *rtda.Frame)

type BALoad

type BALoad struct {
	base.NoOperandsInstruction
}

func (*BALoad) Execute

func (this *BALoad) Execute(frame *rtda.Frame)

type CALoad

type CALoad struct {
	base.NoOperandsInstruction
}

func (*CALoad) Execute

func (this *CALoad) Execute(frame *rtda.Frame)

type DALoad

type DALoad struct {
	base.NoOperandsInstruction
}

func (*DALoad) Execute

func (this *DALoad) Execute(frame *rtda.Frame)

type DLoad

type DLoad struct {
	base.Index8Instruction
}

指令定义来源 The Java® Virtual Machine Specification https://docs.oracle.com/javase/specs/jvms/se8/jvms8.pdf dload Page.399

格式: dload [index] 字节: 0x18 0x01

指令样例     8进制表示     指令含义
dload 1     0x18 0x01    将当前帧(方法)本地变量表下标为 1 的double型变量推到操作数栈

操作: 从当前帧(方法)本地变量表的 index 下标处加载double型变量到操作数栈 描述: index 是一个 无符号的单字节整数

func (*DLoad) Execute

func (this *DLoad) Execute(frame *rtda.Frame)

type DLoad0

type DLoad0 struct {
	base.NoOperandsInstruction
}

指令定义来源 The Java® Virtual Machine Specification https://docs.oracle.com/javase/specs/jvms/se8/jvms8.pdf dload_<n> Page.400

格式: dload_<n> 字节:

指令样例     8进制表示   指令含义
dload_0     0x1e       将当前帧(方法)本地变量表下标为 0 的double型变量推到操作数栈
dload_1     0x1f       将当前帧(方法)本地变量表下标为 1 的double型变量推到操作数栈
dload_2     0x20       将当前帧(方法)本地变量表下标为 2 的double型变量推到操作数栈
dload_3     0x21       将当前帧(方法)本地变量表下标为 3 的double型变量推到操作数栈

操作: 从当前帧(方法)本地变量表的 <n> 下标处加载double型变量到操作数栈, n, n+1 都必须是本地变量表的合法下标 描述:

func (*DLoad0) Execute

func (this *DLoad0) Execute(frame *rtda.Frame)

type DLoad1

type DLoad1 struct {
	base.NoOperandsInstruction
}

func (*DLoad1) Execute

func (this *DLoad1) Execute(frame *rtda.Frame)

type DLoad2

type DLoad2 struct {
	base.NoOperandsInstruction
}

func (*DLoad2) Execute

func (this *DLoad2) Execute(frame *rtda.Frame)

type DLoad3

type DLoad3 struct {
	base.NoOperandsInstruction
}

func (*DLoad3) Execute

func (this *DLoad3) Execute(frame *rtda.Frame)

type FALoad

type FALoad struct {
	base.NoOperandsInstruction
}

func (*FALoad) Execute

func (this *FALoad) Execute(frame *rtda.Frame)

type FLoad

type FLoad struct {
	base.Index8Instruction
}

指令定义来源 The Java® Virtual Machine Specification https://docs.oracle.com/javase/specs/jvms/se8/jvms8.pdf fload Page.429

格式: fload [index] 字节: 0x17 0x01

指令样例     8进制表示     指令含义
fload 1     0x17 0x01    将当前帧(方法)本地变量表下标为 1 的float型变量推到操作数栈

操作: 从当前帧(方法)本地变量表的 index 下标处加载float型变量到操作数栈 描述: index 是一个 无符号的单字节整数

func (*FLoad) Execute

func (this *FLoad) Execute(frame *rtda.Frame)

type FLoad0

type FLoad0 struct {
	base.NoOperandsInstruction
}

指令定义来源 The Java® Virtual Machine Specification https://docs.oracle.com/javase/specs/jvms/se8/jvms8.pdf fload_<n> Page.430

格式: fload_<n> 字节:

指令样例     8进制表示   指令含义
fload_0     0x22       将当前帧(方法)本地变量表下标为 0 的float型变量推到操作数栈
fload_1     0x23       将当前帧(方法)本地变量表下标为 1 的float型变量推到操作数栈
fload_2     0x24       将当前帧(方法)本地变量表下标为 2 的float型变量推到操作数栈
fload_3     0x25       将当前帧(方法)本地变量表下标为 3 的float型变量推到操作数栈

操作: 从当前帧(方法)本地变量表的 <n> 下标处加载float型变量到操作数栈 描述:

func (*FLoad0) Execute

func (this *FLoad0) Execute(frame *rtda.Frame)

type FLoad1

type FLoad1 struct {
	base.NoOperandsInstruction
}

func (*FLoad1) Execute

func (this *FLoad1) Execute(frame *rtda.Frame)

type FLoad2

type FLoad2 struct {
	base.NoOperandsInstruction
}

func (*FLoad2) Execute

func (this *FLoad2) Execute(frame *rtda.Frame)

type FLoad3

type FLoad3 struct {
	base.NoOperandsInstruction
}

func (*FLoad3) Execute

func (this *FLoad3) Execute(frame *rtda.Frame)

type IALoad

type IALoad struct {
	base.NoOperandsInstruction
}

func (*IALoad) Execute

func (this *IALoad) Execute(frame *rtda.Frame)

type ILoad

type ILoad struct {
	base.Index8Instruction
}

指令定义来源 The Java® Virtual Machine Specification https://docs.oracle.com/javase/specs/jvms/se8/jvms8.pdf iload Page.466

格式: iload [index] 字节: 0x15 0x01

指令样例     8进制表示     指令含义
iload 1     0x15 0x01    将当前帧(方法)本地变量表下标为 1 的整型变量推到操作数栈

操作: 从当前帧(方法)本地变量表的 index 下标处加载整型变量到操作数栈 描述: index 是一个 无符号的单字节整数

func (*ILoad) Execute

func (this *ILoad) Execute(frame *rtda.Frame)

type ILoad0

type ILoad0 struct {
	base.NoOperandsInstruction
}

指令定义来源 The Java® Virtual Machine Specification https://docs.oracle.com/javase/specs/jvms/se8/jvms8.pdf iload_<n> Page.467

格式: iload_<n> 字节:

指令样例     8进制表示   指令含义
iload_0     0x1a       将当前帧(方法)本地变量表下标为 0 的整型变量推到操作数栈
iload_1     0x1b       将当前帧(方法)本地变量表下标为 1 的整型变量推到操作数栈
iload_2     0x1c       将当前帧(方法)本地变量表下标为 2 的整型变量推到操作数栈
iload_3     0x1d       将当前帧(方法)本地变量表下标为 3 的整型变量推到操作数栈

操作: 从当前帧(方法)本地变量表的 <n> 下标处加载整型变量到操作数栈 描述:

func (*ILoad0) Execute

func (this *ILoad0) Execute(frame *rtda.Frame)

type ILoad1

type ILoad1 struct {
	base.NoOperandsInstruction
}

func (*ILoad1) Execute

func (this *ILoad1) Execute(frame *rtda.Frame)

type ILoad2

type ILoad2 struct {
	base.NoOperandsInstruction
}

func (*ILoad2) Execute

func (this *ILoad2) Execute(frame *rtda.Frame)

type ILoad3

type ILoad3 struct {
	base.NoOperandsInstruction
}

func (*ILoad3) Execute

func (this *ILoad3) Execute(frame *rtda.Frame)

type LALoad

type LALoad struct {
	base.NoOperandsInstruction
}

func (*LALoad) Execute

func (this *LALoad) Execute(frame *rtda.Frame)

type LLoad

type LLoad struct {
	base.Index8Instruction
}

指令定义来源 The Java® Virtual Machine Specification https://docs.oracle.com/javase/specs/jvms/se8/jvms8.pdf lload Page.521

格式: lload [index] 字节: 0x16 0x01

指令样例     8进制表示     指令含义
lload 1     0x16 0x01    将当前帧(方法)本地变量表下标为 1 的long型变量推到操作数栈

操作: 从当前帧(方法)本地变量表的 index 下标处加载long型变量到操作数栈 描述: index 是一个 无符号的单字节整数

func (*LLoad) Execute

func (this *LLoad) Execute(frame *rtda.Frame)

type LLoad0

type LLoad0 struct {
	base.NoOperandsInstruction
}

指令定义来源 The Java® Virtual Machine Specification https://docs.oracle.com/javase/specs/jvms/se8/jvms8.pdf lload_<n> Page.522

格式: lload_<n> 字节:

指令样例     8进制表示   指令含义
lload_0     0x1e       将当前帧(方法)本地变量表下标为 0 的long型变量推到操作数栈
lload_1     0x1f       将当前帧(方法)本地变量表下标为 1 的long型变量推到操作数栈
lload_2     0x20       将当前帧(方法)本地变量表下标为 2 的long型变量推到操作数栈
lload_3     0x21       将当前帧(方法)本地变量表下标为 3 的long型变量推到操作数栈

操作: 从当前帧(方法)本地变量表的 <n> 下标处加载long型变量到操作数栈, n, n+1 都必须是本地变量表的合法下标 描述:

func (*LLoad0) Execute

func (this *LLoad0) Execute(frame *rtda.Frame)

type LLoad1

type LLoad1 struct {
	base.NoOperandsInstruction
}

func (*LLoad1) Execute

func (this *LLoad1) Execute(frame *rtda.Frame)

type LLoad2

type LLoad2 struct {
	base.NoOperandsInstruction
}

func (*LLoad2) Execute

func (this *LLoad2) Execute(frame *rtda.Frame)

type LLoad3

type LLoad3 struct {
	base.NoOperandsInstruction
}

func (*LLoad3) Execute

func (this *LLoad3) Execute(frame *rtda.Frame)

type SALoad

type SALoad struct {
	base.NoOperandsInstruction
}

func (*SALoad) Execute

func (this *SALoad) Execute(frame *rtda.Frame)

Jump to

Keyboard shortcuts

? : This menu
/ : Search site
f or F : Jump to
y or Y : Canonical URL