Skip to content
体验新版
项目
组织
正在加载...
登录
切换导航
打开侧边栏
wa-lang
wa
提交
86cc8a40
wa
项目概览
wa-lang
/
wa
12 个月 前同步成功
通知
68
Star
655
Fork
45
代码
文件
提交
分支
Tags
贡献者
分支图
Diff
Issue
0
列表
看板
标记
里程碑
合并请求
0
DevOps
流水线
流水线任务
计划
Wiki
0
Wiki
分析
仓库
DevOps
项目成员
Pages
wa
项目概览
项目概览
详情
发布
仓库
仓库
文件
提交
分支
标签
贡献者
分支图
比较
Issue
0
Issue
0
列表
看板
标记
里程碑
合并请求
0
合并请求
0
Pages
DevOps
DevOps
流水线
流水线任务
计划
分析
分析
仓库分析
DevOps
Wiki
0
Wiki
成员
成员
收起侧边栏
关闭侧边栏
动态
分支图
创建新Issue
流水线任务
提交
Issue看板
体验新版 GitCode,发现更多精彩内容 >>
提交
86cc8a40
编写于
7月 25, 2022
作者:
chai2010
浏览文件
操作
浏览文件
下载
电子邮件补丁
差异文件
add internal/3rdparty/wasm
上级
046f84f0
变更
18
展开全部
隐藏空白更改
内联
并排
Showing
18 changed file
with
3537 addition
and
0 deletion
+3537
-0
internal/3rdparty/wasm/constant/constant.go
internal/3rdparty/wasm/constant/constant.go
+77
-0
internal/3rdparty/wasm/encoding/doc.go
internal/3rdparty/wasm/encoding/doc.go
+6
-0
internal/3rdparty/wasm/encoding/encoding_test.go
internal/3rdparty/wasm/encoding/encoding_test.go
+54
-0
internal/3rdparty/wasm/encoding/reader.go
internal/3rdparty/wasm/encoding/reader.go
+946
-0
internal/3rdparty/wasm/encoding/testdata/test1.wasm
internal/3rdparty/wasm/encoding/testdata/test1.wasm
+0
-0
internal/3rdparty/wasm/encoding/writer.go
internal/3rdparty/wasm/encoding/writer.go
+779
-0
internal/3rdparty/wasm/instruction/control.go
internal/3rdparty/wasm/instruction/control.go
+191
-0
internal/3rdparty/wasm/instruction/instruction.go
internal/3rdparty/wasm/instruction/instruction.go
+33
-0
internal/3rdparty/wasm/instruction/memory.go
internal/3rdparty/wasm/instruction/memory.go
+39
-0
internal/3rdparty/wasm/instruction/numeric.go
internal/3rdparty/wasm/instruction/numeric.go
+207
-0
internal/3rdparty/wasm/instruction/parametric.go
internal/3rdparty/wasm/instruction/parametric.go
+29
-0
internal/3rdparty/wasm/instruction/variable.go
internal/3rdparty/wasm/instruction/variable.go
+76
-0
internal/3rdparty/wasm/leb128/leb128.go
internal/3rdparty/wasm/leb128/leb128.go
+170
-0
internal/3rdparty/wasm/leb128/leb128_test.go
internal/3rdparty/wasm/leb128/leb128_test.go
+207
-0
internal/3rdparty/wasm/module/module.go
internal/3rdparty/wasm/module/module.go
+385
-0
internal/3rdparty/wasm/module/pretty.go
internal/3rdparty/wasm/module/pretty.go
+84
-0
internal/3rdparty/wasm/opcode/opcode.go
internal/3rdparty/wasm/opcode/opcode.go
+218
-0
internal/3rdparty/wasm/types/types.go
internal/3rdparty/wasm/types/types.go
+36
-0
未找到文件。
internal/3rdparty/wasm/constant/constant.go
0 → 100644
浏览文件 @
86cc8a40
// Copyright 2018 The OPA Authors. All rights reserved.
// Use of this source code is governed by an Apache2
// license that can be found in the LICENSE file.
// Package constant contains WASM constant definitions.
package
constant
// Magic bytes at the beginning of every WASM file ("\0asm").
const
Magic
=
uint32
(
0x6D736100
)
// Version defines the WASM version.
const
Version
=
uint32
(
1
)
// WASM module section IDs.
const
(
CustomSectionID
uint8
=
iota
TypeSectionID
ImportSectionID
FunctionSectionID
TableSectionID
MemorySectionID
GlobalSectionID
ExportSectionID
StartSectionID
ElementSectionID
CodeSectionID
DataSectionID
)
// FunctionTypeID indicates the start of a function type definition.
const
FunctionTypeID
=
byte
(
0x60
)
// ValueType represents an intrinsic value type in WASM.
const
(
ValueTypeF64
byte
=
iota
+
0x7C
ValueTypeF32
ValueTypeI64
ValueTypeI32
)
// WASM import descriptor types.
const
(
ImportDescType
byte
=
iota
ImportDescTable
ImportDescMem
ImportDescGlobal
)
// WASM export descriptor types.
const
(
ExportDescType
byte
=
iota
ExportDescTable
ExportDescMem
ExportDescGlobal
)
// ElementTypeAnyFunc indicates the type of a table import.
const
ElementTypeAnyFunc
byte
=
0x70
// BlockTypeEmpty represents a block type.
const
BlockTypeEmpty
byte
=
0x40
// WASM global varialbe mutability flag.
const
(
Const
byte
=
iota
Mutable
)
// NameSectionCustomID is the ID of the "Name" section Custom Section
const
NameSectionCustomID
=
"name"
// Subtypes of the 'name' custom section
const
(
NameSectionModuleType
byte
=
iota
NameSectionFunctionsType
NameSectionLocalsType
)
internal/3rdparty/wasm/encoding/doc.go
0 → 100644
浏览文件 @
86cc8a40
// Copyright 2018 The OPA Authors. All rights reserved.
// Use of this source code is governed by an Apache2
// license that can be found in the LICENSE file.
// Package encoding implements WASM module reading and writing.
package
encoding
internal/3rdparty/wasm/encoding/encoding_test.go
0 → 100644
浏览文件 @
86cc8a40
// Copyright 2018 The OPA Authors. All rights reserved.
// Use of this source code is governed by an Apache2
// license that can be found in the LICENSE file.
package
encoding
import
(
"bytes"
"io/ioutil"
"path/filepath"
"reflect"
"testing"
)
func
TestRoundtrip
(
t
*
testing
.
T
)
{
bs
,
err
:=
ioutil
.
ReadFile
(
filepath
.
Join
(
"testdata"
,
"test1.wasm"
))
if
err
!=
nil
{
t
.
Fatal
(
err
)
}
module
,
err
:=
ReadModule
(
bytes
.
NewBuffer
(
bs
))
if
err
!=
nil
{
t
.
Fatal
(
err
)
}
entries
,
err
:=
CodeEntries
(
module
)
if
err
!=
nil
{
t
.
Fatal
(
err
)
}
for
i
,
e
:=
range
entries
{
var
buf3
bytes
.
Buffer
if
err
:=
WriteCodeEntry
(
&
buf3
,
e
);
err
!=
nil
{
t
.
Fatal
(
err
)
}
module
.
Code
.
Segments
[
i
]
.
Code
=
buf3
.
Bytes
()
}
var
buf2
bytes
.
Buffer
if
err
:=
WriteModule
(
&
buf2
,
module
);
err
!=
nil
{
t
.
Fatal
(
err
)
}
module2
,
err
:=
ReadModule
(
&
buf2
)
if
err
!=
nil
{
t
.
Fatal
(
err
)
}
// TODO(tsandall): how to make this more debuggable
if
!
reflect
.
DeepEqual
(
module
,
module2
)
{
t
.
Fatal
(
"modules are not equal"
)
}
}
internal/3rdparty/wasm/encoding/reader.go
0 → 100644
浏览文件 @
86cc8a40
此差异已折叠。
点击以展开。
internal/3rdparty/wasm/encoding/testdata/test1.wasm
0 → 100644
浏览文件 @
86cc8a40
文件已添加
internal/3rdparty/wasm/encoding/writer.go
0 → 100644
浏览文件 @
86cc8a40
// Copyright 2018 The OPA Authors. All rights reserved.
// Use of this source code is governed by an Apache2
// license that can be found in the LICENSE file.
package
encoding
import
(
"bytes"
"encoding/binary"
"fmt"
"io"
"math"
"github.com/wa-lang/wa/internal/3rdparty/wasm/constant"
"github.com/wa-lang/wa/internal/3rdparty/wasm/instruction"
"github.com/wa-lang/wa/internal/3rdparty/wasm/leb128"
"github.com/wa-lang/wa/internal/3rdparty/wasm/module"
"github.com/wa-lang/wa/internal/3rdparty/wasm/opcode"
"github.com/wa-lang/wa/internal/3rdparty/wasm/types"
)
// WriteModule writes a binary-encoded representation of module to w.
func
WriteModule
(
w
io
.
Writer
,
module
*
module
.
Module
)
error
{
if
err
:=
writeMagic
(
w
);
err
!=
nil
{
return
err
}
if
err
:=
writeVersion
(
w
);
err
!=
nil
{
return
err
}
if
module
==
nil
{
return
nil
}
if
err
:=
writeTypeSection
(
w
,
module
.
Type
);
err
!=
nil
{
return
err
}
if
err
:=
writeImportSection
(
w
,
module
.
Import
);
err
!=
nil
{
return
err
}
if
err
:=
writeFunctionSection
(
w
,
module
.
Function
);
err
!=
nil
{
return
err
}
if
err
:=
writeTableSection
(
w
,
module
.
Table
);
err
!=
nil
{
return
err
}
if
err
:=
writeMemorySection
(
w
,
module
.
Memory
);
err
!=
nil
{
return
err
}
if
err
:=
writeGlobalSection
(
w
,
module
.
Global
);
err
!=
nil
{
return
err
}
if
err
:=
writeExportSection
(
w
,
module
.
Export
);
err
!=
nil
{
return
err
}
if
err
:=
writeStartSection
(
w
,
module
.
Start
);
err
!=
nil
{
return
err
}
if
err
:=
writeElementSection
(
w
,
module
.
Element
);
err
!=
nil
{
return
err
}
if
err
:=
writeRawCodeSection
(
w
,
module
.
Code
);
err
!=
nil
{
return
err
}
if
err
:=
writeDataSection
(
w
,
module
.
Data
);
err
!=
nil
{
return
err
}
if
err
:=
writeNameSection
(
w
,
module
.
Names
);
err
!=
nil
{
return
err
}
for
_
,
custom
:=
range
module
.
Customs
{
if
err
:=
writeCustomSection
(
w
,
custom
);
err
!=
nil
{
return
err
}
}
return
nil
}
// WriteCodeEntry writes a binary encoded representation of entry to w.
func
WriteCodeEntry
(
w
io
.
Writer
,
entry
*
module
.
CodeEntry
)
error
{
if
err
:=
leb128
.
WriteVarUint32
(
w
,
uint32
(
len
(
entry
.
Func
.
Locals
)));
err
!=
nil
{
return
err
}
for
_
,
local
:=
range
entry
.
Func
.
Locals
{
if
err
:=
leb128
.
WriteVarUint32
(
w
,
local
.
Count
);
err
!=
nil
{
return
err
}
if
err
:=
writeValueType
(
w
,
local
.
Type
);
err
!=
nil
{
return
err
}
}
return
writeInstructions
(
w
,
entry
.
Func
.
Expr
.
Instrs
)
}
func
writeMagic
(
w
io
.
Writer
)
error
{
return
binary
.
Write
(
w
,
binary
.
LittleEndian
,
constant
.
Magic
)
}
func
writeVersion
(
w
io
.
Writer
)
error
{
return
binary
.
Write
(
w
,
binary
.
LittleEndian
,
constant
.
Version
)
}
func
writeMemorySection
(
w
io
.
Writer
,
s
module
.
MemorySection
)
error
{
if
len
(
s
.
Memorys
)
==
0
{
return
nil
}
if
len
(
s
.
Memorys
)
>
1
{
return
fmt
.
Errorf
(
"only one memory block allowed"
)
}
if
err
:=
writeByte
(
w
,
constant
.
MemorySectionID
);
err
!=
nil
{
return
err
}
var
buf
bytes
.
Buffer
if
err
:=
leb128
.
WriteVarUint32
(
&
buf
,
uint32
(
len
(
s
.
Memorys
)));
err
!=
nil
{
return
err
}
for
_
,
mem
:=
range
s
.
Memorys
{
if
mem
.
MaxPages
>
0
{
if
err
:=
writeByte
(
&
buf
,
1
);
err
!=
nil
{
return
err
}
if
err
:=
leb128
.
WriteVarUint32
(
&
buf
,
mem
.
InitPages
);
err
!=
nil
{
return
err
}
if
err
:=
leb128
.
WriteVarUint32
(
&
buf
,
mem
.
MaxPages
);
err
!=
nil
{
return
err
}
}
else
{
if
err
:=
writeByte
(
&
buf
,
0
);
err
!=
nil
{
return
err
}
if
err
:=
leb128
.
WriteVarUint32
(
&
buf
,
mem
.
InitPages
);
err
!=
nil
{
return
err
}
}
}
return
writeRawSection
(
w
,
&
buf
)
}
func
writeStartSection
(
w
io
.
Writer
,
s
module
.
StartSection
)
error
{
if
s
.
FuncIndex
==
nil
{
return
nil
}
if
err
:=
writeByte
(
w
,
constant
.
StartSectionID
);
err
!=
nil
{
return
err
}
var
buf
bytes
.
Buffer
if
err
:=
leb128
.
WriteVarUint32
(
&
buf
,
*
s
.
FuncIndex
);
err
!=
nil
{
return
err
}
return
writeRawSection
(
w
,
&
buf
)
}
func
writeTypeSection
(
w
io
.
Writer
,
s
module
.
TypeSection
)
error
{
if
len
(
s
.
Functions
)
==
0
{
return
nil
}
if
err
:=
writeByte
(
w
,
constant
.
TypeSectionID
);
err
!=
nil
{
return
err
}
var
buf
bytes
.
Buffer
if
err
:=
leb128
.
WriteVarUint32
(
&
buf
,
uint32
(
len
(
s
.
Functions
)));
err
!=
nil
{
return
err
}
for
_
,
fsig
:=
range
s
.
Functions
{
if
err
:=
writeFunctionType
(
&
buf
,
fsig
);
err
!=
nil
{
return
err
}
}
return
writeRawSection
(
w
,
&
buf
)
}
func
writeImportSection
(
w
io
.
Writer
,
s
module
.
ImportSection
)
error
{
if
len
(
s
.
Imports
)
==
0
{
return
nil
}
if
err
:=
writeByte
(
w
,
constant
.
ImportSectionID
);
err
!=
nil
{
return
err
}
var
buf
bytes
.
Buffer
if
err
:=
leb128
.
WriteVarUint32
(
&
buf
,
uint32
(
len
(
s
.
Imports
)));
err
!=
nil
{
return
err
}
for
_
,
imp
:=
range
s
.
Imports
{
if
err
:=
writeImport
(
&
buf
,
imp
);
err
!=
nil
{
return
err
}
}
return
writeRawSection
(
w
,
&
buf
)
}
func
writeGlobalSection
(
w
io
.
Writer
,
s
module
.
GlobalSection
)
error
{
if
len
(
s
.
Globals
)
==
0
{
return
nil
}
if
err
:=
writeByte
(
w
,
constant
.
GlobalSectionID
);
err
!=
nil
{
return
err
}
var
buf
bytes
.
Buffer
if
err
:=
leb128
.
WriteVarUint32
(
&
buf
,
uint32
(
len
(
s
.
Globals
)));
err
!=
nil
{
return
err
}
for
_
,
global
:=
range
s
.
Globals
{
if
err
:=
writeGlobal
(
&
buf
,
global
);
err
!=
nil
{
return
err
}
}
return
writeRawSection
(
w
,
&
buf
)
}
func
writeFunctionSection
(
w
io
.
Writer
,
s
module
.
FunctionSection
)
error
{
if
len
(
s
.
TypeIndices
)
==
0
{
return
nil
}
if
err
:=
writeByte
(
w
,
constant
.
FunctionSectionID
);
err
!=
nil
{
return
err
}
var
buf
bytes
.
Buffer
if
err
:=
leb128
.
WriteVarUint32
(
&
buf
,
uint32
(
len
(
s
.
TypeIndices
)));
err
!=
nil
{
return
err
}
for
_
,
idx
:=
range
s
.
TypeIndices
{
if
err
:=
leb128
.
WriteVarUint32
(
&
buf
,
uint32
(
idx
));
err
!=
nil
{
return
err
}
}
return
writeRawSection
(
w
,
&
buf
)
}
func
writeTableSection
(
w
io
.
Writer
,
s
module
.
TableSection
)
error
{
if
len
(
s
.
Tables
)
==
0
{
return
nil
}
if
err
:=
writeByte
(
w
,
constant
.
TableSectionID
);
err
!=
nil
{
return
err
}
var
buf
bytes
.
Buffer
if
err
:=
leb128
.
WriteVarUint32
(
&
buf
,
uint32
(
len
(
s
.
Tables
)));
err
!=
nil
{
return
err
}
for
_
,
table
:=
range
s
.
Tables
{
switch
table
.
Type
{
case
types
.
Anyfunc
:
if
err
:=
writeByte
(
&
buf
,
constant
.
ElementTypeAnyFunc
);
err
!=
nil
{
return
err
}
default
:
return
fmt
.
Errorf
(
"illegal table element type"
)
}
if
err
:=
writeLimits
(
&
buf
,
table
.
Lim
);
err
!=
nil
{
return
err
}
}
return
writeRawSection
(
w
,
&
buf
)
}
func
writeExportSection
(
w
io
.
Writer
,
s
module
.
ExportSection
)
error
{
if
len
(
s
.
Exports
)
==
0
{
return
nil
}
if
err
:=
writeByte
(
w
,
constant
.
ExportSectionID
);
err
!=
nil
{
return
err
}
var
buf
bytes
.
Buffer
if
err
:=
leb128
.
WriteVarUint32
(
&
buf
,
uint32
(
len
(
s
.
Exports
)));
err
!=
nil
{
return
err
}
for
_
,
exp
:=
range
s
.
Exports
{
if
err
:=
writeByteVector
(
&
buf
,
[]
byte
(
exp
.
Name
));
err
!=
nil
{
return
err
}
var
tpe
byte
switch
exp
.
Descriptor
.
Type
{
case
module
.
FunctionExportType
:
tpe
=
constant
.
ExportDescType
case
module
.
TableExportType
:
tpe
=
constant
.
ExportDescTable
case
module
.
MemoryExportType
:
tpe
=
constant
.
ExportDescMem
case
module
.
GlobalExportType
:
tpe
=
constant
.
ExportDescGlobal
default
:
return
fmt
.
Errorf
(
"illegal export descriptor type 0x%x"
,
exp
.
Descriptor
.
Type
)
}
if
err
:=
writeByte
(
&
buf
,
tpe
);
err
!=
nil
{
return
err
}
if
err
:=
leb128
.
WriteVarUint32
(
&
buf
,
exp
.
Descriptor
.
Index
);
err
!=
nil
{
return
err
}
}
return
writeRawSection
(
w
,
&
buf
)
}
func
writeElementSection
(
w
io
.
Writer
,
s
module
.
ElementSection
)
error
{
if
len
(
s
.
Segments
)
==
0
{
return
nil
}
if
err
:=
writeByte
(
w
,
constant
.
ElementSectionID
);
err
!=
nil
{
return
err
}
var
buf
bytes
.
Buffer
if
err
:=
leb128
.
WriteVarUint32
(
&
buf
,
uint32
(
len
(
s
.
Segments
)));
err
!=
nil
{
return
err
}
for
_
,
seg
:=
range
s
.
Segments
{
if
err
:=
leb128
.
WriteVarUint32
(
&
buf
,
seg
.
Index
);
err
!=
nil
{
return
err
}
if
err
:=
writeInstructions
(
&
buf
,
seg
.
Offset
.
Instrs
);
err
!=
nil
{
return
err
}
if
err
:=
writeVarUint32Vector
(
&
buf
,
seg
.
Indices
);
err
!=
nil
{
return
err
}
}
return
writeRawSection
(
w
,
&
buf
)
}
func
writeRawCodeSection
(
w
io
.
Writer
,
s
module
.
RawCodeSection
)
error
{
if
len
(
s
.
Segments
)
==
0
{
return
nil
}
if
err
:=
writeByte
(
w
,
constant
.
CodeSectionID
);
err
!=
nil
{
return
err
}
var
buf
bytes
.
Buffer
if
err
:=
leb128
.
WriteVarUint32
(
&
buf
,
uint32
(
len
(
s
.
Segments
)));
err
!=
nil
{
return
err
}
for
_
,
seg
:=
range
s
.
Segments
{
if
err
:=
leb128
.
WriteVarUint32
(
&
buf
,
uint32
(
len
(
seg
.
Code
)));
err
!=
nil
{
return
err
}
if
_
,
err
:=
buf
.
Write
(
seg
.
Code
);
err
!=
nil
{
return
err
}
}
return
writeRawSection
(
w
,
&
buf
)
}
func
writeDataSection
(
w
io
.
Writer
,
s
module
.
DataSection
)
error
{
if
len
(
s
.
Segments
)
==
0
{
return
nil
}
if
err
:=
writeByte
(
w
,
constant
.
DataSectionID
);
err
!=
nil
{
return
err
}
var
buf
bytes
.
Buffer
if
err
:=
leb128
.
WriteVarUint32
(
&
buf
,
uint32
(
len
(
s
.
Segments
)));
err
!=
nil
{
return
err
}
for
_
,
seg
:=
range
s
.
Segments
{
if
err
:=
leb128
.
WriteVarUint32
(
&
buf
,
seg
.
Index
);
err
!=
nil
{
return
err
}
if
err
:=
writeInstructions
(
&
buf
,
seg
.
Offset
.
Instrs
);
err
!=
nil
{
return
err
}
if
err
:=
writeByteVector
(
&
buf
,
seg
.
Init
);
err
!=
nil
{
return
err
}
}
return
writeRawSection
(
w
,
&
buf
)
}
func
writeNameSection
(
w
io
.
Writer
,
s
module
.
NameSection
)
error
{
if
s
.
Module
==
""
&&
len
(
s
.
Functions
)
==
0
&&
len
(
s
.
Locals
)
==
0
{
return
nil
}
if
err
:=
writeByte
(
w
,
constant
.
CustomSectionID
);
err
!=
nil
{
return
err
}
var
buf
bytes
.
Buffer
if
err
:=
writeByteVector
(
&
buf
,
[]
byte
(
constant
.
NameSectionCustomID
));
err
!=
nil
{
return
err
}
// "module" subsection
if
s
.
Module
!=
""
{
if
err
:=
writeByte
(
&
buf
,
constant
.
NameSectionModuleType
);
err
!=
nil
{
return
err
}
var
mbuf
bytes
.
Buffer
if
err
:=
writeByteVector
(
&
mbuf
,
[]
byte
(
s
.
Module
));
err
!=
nil
{
return
err
}
if
err
:=
writeRawSection
(
&
buf
,
&
mbuf
);
err
!=
nil
{
return
err
}
}
// "functions" subsection
if
len
(
s
.
Functions
)
!=
0
{
if
err
:=
writeByte
(
&
buf
,
constant
.
NameSectionFunctionsType
);
err
!=
nil
{
return
err
}
var
fbuf
bytes
.
Buffer
if
err
:=
writeNameMap
(
&
fbuf
,
s
.
Functions
);
err
!=
nil
{
return
err
}
if
err
:=
writeRawSection
(
&
buf
,
&
fbuf
);
err
!=
nil
{
return
err
}
}
// "locals" subsection
if
len
(
s
.
Locals
)
!=
0
{
if
err
:=
writeByte
(
&
buf
,
constant
.
NameSectionLocalsType
);
err
!=
nil
{
return
err
}
funs
:=
map
[
uint32
][]
module
.
NameMap
{}
for
_
,
e
:=
range
s
.
Locals
{
funs
[
e
.
FuncIndex
]
=
append
(
funs
[
e
.
FuncIndex
],
module
.
NameMap
{
Index
:
e
.
Index
,
Name
:
e
.
Name
})
}
var
lbuf
bytes
.
Buffer
if
err
:=
leb128
.
WriteVarUint32
(
&
lbuf
,
uint32
(
len
(
funs
)));
err
!=
nil
{
return
err
}
for
fidx
,
e
:=
range
funs
{
if
err
:=
leb128
.
WriteVarUint32
(
&
lbuf
,
fidx
);
err
!=
nil
{
return
err
}
if
err
:=
writeNameMap
(
&
lbuf
,
e
);
err
!=
nil
{
return
err
}
}
if
err
:=
writeRawSection
(
&
buf
,
&
lbuf
);
err
!=
nil
{
return
err
}
}
return
writeRawSection
(
w
,
&
buf
)
}
func
writeNameMap
(
buf
io
.
Writer
,
nm
[]
module
.
NameMap
)
error
{
if
err
:=
leb128
.
WriteVarUint32
(
buf
,
uint32
(
len
(
nm
)));
err
!=
nil
{
return
err
}
for
_
,
m
:=
range
nm
{
if
err
:=
leb128
.
WriteVarUint32
(
buf
,
m
.
Index
);
err
!=
nil
{
return
err
}
if
err
:=
writeByteVector
(
buf
,
[]
byte
(
m
.
Name
));
err
!=
nil
{
return
err
}
}
return
nil
}
func
writeCustomSection
(
w
io
.
Writer
,
s
module
.
CustomSection
)
error
{
if
err
:=
writeByte
(
w
,
constant
.
CustomSectionID
);
err
!=
nil
{
return
err
}
var
buf
bytes
.
Buffer
if
err
:=
writeByteVector
(
&
buf
,
[]
byte
(
s
.
Name
));
err
!=
nil
{
return
err
}
if
_
,
err
:=
io
.
Copy
(
&
buf
,
bytes
.
NewReader
(
s
.
Data
));
err
!=
nil
{
return
err
}
return
writeRawSection
(
w
,
&
buf
)
}
func
writeFunctionType
(
w
io
.
Writer
,
fsig
module
.
FunctionType
)
error
{
if
err
:=
writeByte
(
w
,
constant
.
FunctionTypeID
);
err
!=
nil
{
return
err
}
if
err
:=
writeValueTypeVector
(
w
,
fsig
.
Params
);
err
!=
nil
{
return
err
}
return
writeValueTypeVector
(
w
,
fsig
.
Results
)
}
func
writeImport
(
w
io
.
Writer
,
imp
module
.
Import
)
error
{
if
err
:=
writeByteVector
(
w
,
[]
byte
(
imp
.
Module
));
err
!=
nil
{
return
err
}
if
err
:=
writeByteVector
(
w
,
[]
byte
(
imp
.
Name
));
err
!=
nil
{
return
err
}
switch
desc
:=
imp
.
Descriptor
.
(
type
)
{
case
module
.
FunctionImport
:
if
err
:=
writeByte
(
w
,
constant
.
ImportDescType
);
err
!=
nil
{
return
err
}
return
leb128
.
WriteVarUint32
(
w
,
desc
.
Func
)
case
module
.
TableImport
:
if
err
:=
writeByte
(
w
,
constant
.
ImportDescTable
);
err
!=
nil
{
return
err
}
if
err
:=
writeByte
(
w
,
constant
.
ElementTypeAnyFunc
);
err
!=
nil
{
return
err
}
return
writeLimits
(
w
,
desc
.
Lim
)
case
module
.
MemoryImport
:
if
err
:=
writeByte
(
w
,
constant
.
ImportDescMem
);
err
!=
nil
{
return
err
}
return
writeLimits
(
w
,
desc
.
Mem
.
Lim
)
case
module
.
GlobalImport
:
if
err
:=
writeByte
(
w
,
constant
.
ImportDescGlobal
);
err
!=
nil
{
return
err
}
if
err
:=
writeValueType
(
w
,
desc
.
Type
);
err
!=
nil
{
return
err
}
if
desc
.
Mutable
{
return
writeByte
(
w
,
constant
.
Mutable
)
}
return
writeByte
(
w
,
constant
.
Const
)
default
:
return
fmt
.
Errorf
(
"illegal import descriptor type"
)
}
}
func
writeGlobal
(
w
io
.
Writer
,
global
module
.
Global
)
error
{
if
err
:=
writeValueType
(
w
,
global
.
Type
);
err
!=
nil
{
return
err
}
var
err
error
if
global
.
Mutable
{
err
=
writeByte
(
w
,
constant
.
Mutable
)
}
else
{
err
=
writeByte
(
w
,
constant
.
Const
)
}
if
err
!=
nil
{
return
err
}
return
writeInstructions
(
w
,
global
.
Init
.
Instrs
)
}
func
writeInstructions
(
w
io
.
Writer
,
instrs
[]
instruction
.
Instruction
)
error
{
for
i
,
instr
:=
range
instrs
{
_
,
err
:=
w
.
Write
([]
byte
{
byte
(
instr
.
Op
())})
if
err
!=
nil
{
return
err
}
for
_
,
arg
:=
range
instr
.
ImmediateArgs
()
{
var
err
error
switch
arg
:=
arg
.
(
type
)
{
case
int32
:
err
=
leb128
.
WriteVarInt32
(
w
,
arg
)
case
int64
:
err
=
leb128
.
WriteVarInt64
(
w
,
arg
)
case
uint32
:
err
=
leb128
.
WriteVarUint32
(
w
,
arg
)
case
uint64
:
err
=
leb128
.
WriteVarUint64
(
w
,
arg
)
case
float32
:
u32
:=
math
.
Float32bits
(
arg
)
err
=
binary
.
Write
(
w
,
binary
.
LittleEndian
,
u32
)
case
float64
:
u64
:=
math
.
Float64bits
(
arg
)
err
=
binary
.
Write
(
w
,
binary
.
LittleEndian
,
u64
)
case
byte
:
_
,
err
=
w
.
Write
([]
byte
{
arg
})
default
:
return
fmt
.
Errorf
(
"illegal immediate argument type on instruction %d"
,
i
)
}
if
err
!=
nil
{
return
err
}
}
if
si
,
ok
:=
instr
.
(
instruction
.
StructuredInstruction
);
ok
{
if
err
:=
writeBlockValueType
(
w
,
si
.
BlockType
());
err
!=
nil
{
return
err
}
if
err
:=
writeInstructions
(
w
,
si
.
Instructions
());
err
!=
nil
{
return
err
}
}
}
_
,
err
:=
w
.
Write
([]
byte
{
byte
(
opcode
.
End
)})
return
err
}
func
writeLimits
(
w
io
.
Writer
,
lim
module
.
Limit
)
error
{
if
lim
.
Max
==
nil
{
if
err
:=
writeByte
(
w
,
0
);
err
!=
nil
{
return
err
}
}
else
{
if
err
:=
writeByte
(
w
,
1
);
err
!=
nil
{
return
err
}
}
if
err
:=
leb128
.
WriteVarUint32
(
w
,
lim
.
Min
);
err
!=
nil
{
return
err
}
if
lim
.
Max
!=
nil
{
return
leb128
.
WriteVarUint32
(
w
,
*
lim
.
Max
)
}
return
nil
}
func
writeVarUint32Vector
(
w
io
.
Writer
,
v
[]
uint32
)
error
{
if
err
:=
leb128
.
WriteVarUint32
(
w
,
uint32
(
len
(
v
)));
err
!=
nil
{
return
err
}
for
i
:=
range
v
{
if
err
:=
leb128
.
WriteVarUint32
(
w
,
v
[
i
]);
err
!=
nil
{
return
err
}
}
return
nil
}
func
writeValueTypeVector
(
w
io
.
Writer
,
v
[]
types
.
ValueType
)
error
{
if
err
:=
leb128
.
WriteVarUint32
(
w
,
uint32
(
len
(
v
)));
err
!=
nil
{
return
err
}
for
i
:=
range
v
{
if
err
:=
writeValueType
(
w
,
v
[
i
]);
err
!=
nil
{
return
err
}
}
return
nil
}
func
writeBlockValueType
(
w
io
.
Writer
,
v
*
types
.
ValueType
)
error
{
var
b
byte
if
v
!=
nil
{
switch
*
v
{
case
types
.
I32
:
b
=
constant
.
ValueTypeI32
case
types
.
I64
:
b
=
constant
.
ValueTypeI64
case
types
.
F32
:
b
=
constant
.
ValueTypeF32
case
types
.
F64
:
b
=
constant
.
ValueTypeF64
}
}
else
{
b
=
constant
.
BlockTypeEmpty
}
return
writeByte
(
w
,
b
)
}
func
writeValueType
(
w
io
.
Writer
,
v
types
.
ValueType
)
error
{
var
b
byte
switch
v
{
case
types
.
I32
:
b
=
constant
.
ValueTypeI32
case
types
.
I64
:
b
=
constant
.
ValueTypeI64
case
types
.
F32
:
b
=
constant
.
ValueTypeF32
case
types
.
F64
:
b
=
constant
.
ValueTypeF64
}
return
writeByte
(
w
,
b
)
}
func
writeRawSection
(
w
io
.
Writer
,
buf
*
bytes
.
Buffer
)
error
{
size
:=
buf
.
Len
()
if
err
:=
leb128
.
WriteVarUint32
(
w
,
uint32
(
size
));
err
!=
nil
{
return
err
}
_
,
err
:=
io
.
Copy
(
w
,
buf
)
return
err
}
func
writeByteVector
(
w
io
.
Writer
,
bs
[]
byte
)
error
{
if
err
:=
leb128
.
WriteVarUint32
(
w
,
uint32
(
len
(
bs
)));
err
!=
nil
{
return
err
}
_
,
err
:=
w
.
Write
(
bs
)
return
err
}
func
writeByte
(
w
io
.
Writer
,
b
byte
)
error
{
buf
:=
make
([]
byte
,
1
)
buf
[
0
]
=
b
_
,
err
:=
w
.
Write
(
buf
)
return
err
}
internal/3rdparty/wasm/instruction/control.go
0 → 100644
浏览文件 @
86cc8a40
// Copyright 2018 The OPA Authors. All rights reserved.
// Use of this source code is governed by an Apache2
// license that can be found in the LICENSE file.
package
instruction
import
(
"github.com/wa-lang/wa/internal/3rdparty/wasm/opcode"
"github.com/wa-lang/wa/internal/3rdparty/wasm/types"
)
// !!! If you find yourself adding support for more control
// instructions (br_table, if, ...), please adapt the
// `withControlInstr` functions of
// `compiler/wasm/optimizations.go`
// Unreachable represents a WASM unreachable instruction.
type
Unreachable
struct
{
NoImmediateArgs
}
// Op returns the opcode of the instruction.
func
(
Unreachable
)
Op
()
opcode
.
Opcode
{
return
opcode
.
Unreachable
}
// Nop represents a WASM no-op instruction.
type
Nop
struct
{
NoImmediateArgs
}
// Op returns the opcode of the instruction.
func
(
Nop
)
Op
()
opcode
.
Opcode
{
return
opcode
.
Nop
}
// Block represents a WASM block instruction.
type
Block
struct
{
NoImmediateArgs
Type
*
types
.
ValueType
Instrs
[]
Instruction
}
// Op returns the opcode of the instruction
func
(
Block
)
Op
()
opcode
.
Opcode
{
return
opcode
.
Block
}
// BlockType returns the type of the block's return value.
func
(
i
Block
)
BlockType
()
*
types
.
ValueType
{
return
i
.
Type
}
// Instructions returns the instructions contained in the block.
func
(
i
Block
)
Instructions
()
[]
Instruction
{
return
i
.
Instrs
}
// If represents a WASM if instruction.
// NOTE(sr): we only use if with one branch so far!
type
If
struct
{
NoImmediateArgs
Type
*
types
.
ValueType
Instrs
[]
Instruction
}
// Op returns the opcode of the instruction.
func
(
If
)
Op
()
opcode
.
Opcode
{
return
opcode
.
If
}
// BlockType returns the type of the if's THEN branch.
func
(
i
If
)
BlockType
()
*
types
.
ValueType
{
return
i
.
Type
}
// Instructions represents the instructions contained in the if's THEN branch.
func
(
i
If
)
Instructions
()
[]
Instruction
{
return
i
.
Instrs
}
// Loop represents a WASM loop instruction.
type
Loop
struct
{
NoImmediateArgs
Type
*
types
.
ValueType
Instrs
[]
Instruction
}
// Op returns the opcode of the instruction.
func
(
Loop
)
Op
()
opcode
.
Opcode
{
return
opcode
.
Loop
}
// BlockType returns the type of the loop's return value.
func
(
i
Loop
)
BlockType
()
*
types
.
ValueType
{
return
i
.
Type
}
// Instructions represents the instructions contained in the loop.
func
(
i
Loop
)
Instructions
()
[]
Instruction
{
return
i
.
Instrs
}
// Br represents a WASM br instruction.
type
Br
struct
{
Index
uint32
}
// Op returns the opcode of the instruction.
func
(
Br
)
Op
()
opcode
.
Opcode
{
return
opcode
.
Br
}
// ImmediateArgs returns the block index to break to.
func
(
i
Br
)
ImmediateArgs
()
[]
interface
{}
{
return
[]
interface
{}{
i
.
Index
}
}
// BrIf represents a WASM br_if instruction.
type
BrIf
struct
{
Index
uint32
}
// Op returns the opcode of the instruction.
func
(
BrIf
)
Op
()
opcode
.
Opcode
{
return
opcode
.
BrIf
}
// ImmediateArgs returns the block index to break to.
func
(
i
BrIf
)
ImmediateArgs
()
[]
interface
{}
{
return
[]
interface
{}{
i
.
Index
}
}
// Call represents a WASM call instruction.
type
Call
struct
{
Index
uint32
}
// Op returns the opcode of the instruction.
func
(
Call
)
Op
()
opcode
.
Opcode
{
return
opcode
.
Call
}
// ImmediateArgs returns the function index.
func
(
i
Call
)
ImmediateArgs
()
[]
interface
{}
{
return
[]
interface
{}{
i
.
Index
}
}
// CallIndirect represents a WASM call_indirect instruction.
type
CallIndirect
struct
{
Index
uint32
// type index
Reserved
byte
// zero for now
}
// Op returns the opcode of the instruction.
func
(
CallIndirect
)
Op
()
opcode
.
Opcode
{
return
opcode
.
CallIndirect
}
// ImmediateArgs returns the function index.
func
(
i
CallIndirect
)
ImmediateArgs
()
[]
interface
{}
{
return
[]
interface
{}{
i
.
Index
,
i
.
Reserved
}
}
// Return represents a WASM return instruction.
type
Return
struct
{
NoImmediateArgs
}
// Op returns the opcode of the instruction.
func
(
Return
)
Op
()
opcode
.
Opcode
{
return
opcode
.
Return
}
// End represents the special WASM end instruction.
type
End
struct
{
NoImmediateArgs
}
// Op returns the opcode of the instruction.
func
(
End
)
Op
()
opcode
.
Opcode
{
return
opcode
.
End
}
type
Else
struct
{
NoImmediateArgs
}
func
(
Else
)
Op
()
opcode
.
Opcode
{
return
opcode
.
Else
}
internal/3rdparty/wasm/instruction/instruction.go
0 → 100644
浏览文件 @
86cc8a40
// Copyright 2018 The OPA Authors. All rights reserved.
// Use of this source code is governed by an Apache2
// license that can be found in the LICENSE file.
// Package instruction defines WASM instruction types.
package
instruction
import
(
"github.com/wa-lang/wa/internal/3rdparty/wasm/opcode"
"github.com/wa-lang/wa/internal/3rdparty/wasm/types"
)
// NoImmediateArgs indicates the instruction has no immediate arguments.
type
NoImmediateArgs
struct
{
}
// ImmediateArgs returns the immedate arguments of an instruction.
func
(
NoImmediateArgs
)
ImmediateArgs
()
[]
interface
{}
{
return
nil
}
// Instruction represents a single WASM instruction.
type
Instruction
interface
{
Op
()
opcode
.
Opcode
ImmediateArgs
()
[]
interface
{}
}
// StructuredInstruction represents a structured control instruction like br_if.
type
StructuredInstruction
interface
{
Instruction
BlockType
()
*
types
.
ValueType
Instructions
()
[]
Instruction
}
internal/3rdparty/wasm/instruction/memory.go
0 → 100644
浏览文件 @
86cc8a40
// Copyright 2019 The OPA Authors. All rights reserved.
// Use of this source code is governed by an Apache2
// license that can be found in the LICENSE file.
package
instruction
import
"github.com/wa-lang/wa/internal/3rdparty/wasm/opcode"
// I32Load represents the WASM i32.load instruction.
type
I32Load
struct
{
Offset
int32
Align
int32
// expressed as a power of two
}
// Op returns the opcode of the instruction.
func
(
I32Load
)
Op
()
opcode
.
Opcode
{
return
opcode
.
I32Load
}
// ImmediateArgs returns the static offset and alignment operands.
func
(
i
I32Load
)
ImmediateArgs
()
[]
interface
{}
{
return
[]
interface
{}{
i
.
Align
,
i
.
Offset
}
}
// I32Store represents the WASM i32.store instruction.
type
I32Store
struct
{
Offset
int32
Align
int32
// expressed as a power of two
}
// Op returns the opcode of the instruction.
func
(
I32Store
)
Op
()
opcode
.
Opcode
{
return
opcode
.
I32Store
}
// ImmediateArgs returns the static offset and alignment operands.
func
(
i
I32Store
)
ImmediateArgs
()
[]
interface
{}
{
return
[]
interface
{}{
i
.
Align
,
i
.
Offset
}
}
internal/3rdparty/wasm/instruction/numeric.go
0 → 100644
浏览文件 @
86cc8a40
// Copyright 2018 The OPA Authors. All rights reserved.
// Use of this source code is governed by an Apache2
// license that can be found in the LICENSE file.
package
instruction
import
(
"github.com/wa-lang/wa/internal/3rdparty/wasm/opcode"
)
// I32Const represents the WASM i32.const instruction.
type
I32Const
struct
{
Value
int32
}
// Op returns the opcode of the instruction.
func
(
I32Const
)
Op
()
opcode
.
Opcode
{
return
opcode
.
I32Const
}
// ImmediateArgs returns the i32 value to push onto the stack.
func
(
i
I32Const
)
ImmediateArgs
()
[]
interface
{}
{
return
[]
interface
{}{
i
.
Value
}
}
// I64Const represents the WASM i64.const instruction.
type
I64Const
struct
{
Value
int64
}
// Op returns the opcode of the instruction.
func
(
I64Const
)
Op
()
opcode
.
Opcode
{
return
opcode
.
I64Const
}
// ImmediateArgs returns the i64 value to push onto the stack.
func
(
i
I64Const
)
ImmediateArgs
()
[]
interface
{}
{
return
[]
interface
{}{
i
.
Value
}
}
// F32Const represents the WASM f32.const instruction.
type
F32Const
struct
{
Value
int32
}
// Op returns the opcode of the instruction.
func
(
F32Const
)
Op
()
opcode
.
Opcode
{
return
opcode
.
F32Const
}
// ImmediateArgs returns the f32 value to push onto the stack.
func
(
i
F32Const
)
ImmediateArgs
()
[]
interface
{}
{
return
[]
interface
{}{
i
.
Value
}
}
// F64Const represents the WASM f64.const instruction.
type
F64Const
struct
{
Value
float64
}
// Op returns the opcode of the instruction.
func
(
F64Const
)
Op
()
opcode
.
Opcode
{
return
opcode
.
F64Const
}
// ImmediateArgs returns the f64 value to push onto the stack.
func
(
i
F64Const
)
ImmediateArgs
()
[]
interface
{}
{
return
[]
interface
{}{
i
.
Value
}
}
// I32Eqz represents the WASM i32.eqz instruction.
type
I32Eqz
struct
{
NoImmediateArgs
}
// Op returns the opcode of the instruction.
func
(
I32Eqz
)
Op
()
opcode
.
Opcode
{
return
opcode
.
I32Eqz
}
// I32Eq represents the WASM i32.eq instruction.
type
I32Eq
struct
{
NoImmediateArgs
}
// Op returns the opcode of the instruction.
func
(
I32Eq
)
Op
()
opcode
.
Opcode
{
return
opcode
.
I32Eq
}
// I32Ne represents the WASM i32.ne instruction.
type
I32Ne
struct
{
NoImmediateArgs
}
// Op returns the opcode of the instruction.
func
(
I32Ne
)
Op
()
opcode
.
Opcode
{
return
opcode
.
I32Ne
}
// I32GtS represents the WASM i32.gt_s instruction.
type
I32GtS
struct
{
NoImmediateArgs
}
// Op returns the opcode of the instruction.
func
(
I32GtS
)
Op
()
opcode
.
Opcode
{
return
opcode
.
I32GtS
}
// I32GeS represents the WASM i32.ge_s instruction.
type
I32GeS
struct
{
NoImmediateArgs
}
// Op returns the opcode of the instruction.
func
(
I32GeS
)
Op
()
opcode
.
Opcode
{
return
opcode
.
I32GeS
}
// I32LtS represents the WASM i32.lt_s instruction.
type
I32LtS
struct
{
NoImmediateArgs
}
// Op returns the opcode of the instruction.
func
(
I32LtS
)
Op
()
opcode
.
Opcode
{
return
opcode
.
I32LtS
}
// I32LeS represents the WASM i32.le_s instruction.
type
I32LeS
struct
{
NoImmediateArgs
}
// Op returns the opcode of the instruction.
func
(
I32LeS
)
Op
()
opcode
.
Opcode
{
return
opcode
.
I32LeS
}
// I32Add represents the WASM i32.add instruction.
type
I32Add
struct
{
NoImmediateArgs
}
// Op returns the opcode of the instruction.
func
(
I32Add
)
Op
()
opcode
.
Opcode
{
return
opcode
.
I32Add
}
// I64Add represents the WASM i64.add instruction.
type
I64Add
struct
{
NoImmediateArgs
}
// Op returns the opcode of the instruction.
func
(
I64Add
)
Op
()
opcode
.
Opcode
{
return
opcode
.
I64Add
}
// F32Add represents the WASM f32.add instruction.
type
F32Add
struct
{
NoImmediateArgs
}
// Op returns the opcode of the instruction.
func
(
F32Add
)
Op
()
opcode
.
Opcode
{
return
opcode
.
F32Add
}
// F64Add represents the WASM f64.add instruction.
type
F64Add
struct
{
NoImmediateArgs
}
// Op returns the opcode of the instruction.
func
(
F64Add
)
Op
()
opcode
.
Opcode
{
return
opcode
.
F64Add
}
// I32Mul represents the WASM i32.mul instruction.
type
I32Mul
struct
{
NoImmediateArgs
}
// Op returns the opcode of the instruction.
func
(
I32Mul
)
Op
()
opcode
.
Opcode
{
return
opcode
.
I32Mul
}
// I32Sub represents the WASM i32.sub instruction.
type
I32Sub
struct
{
NoImmediateArgs
}
// Op returns the opcode of the instruction.
func
(
I32Sub
)
Op
()
opcode
.
Opcode
{
return
opcode
.
I32Sub
}
type
I32DivS
struct
{
NoImmediateArgs
}
func
(
I32DivS
)
Op
()
opcode
.
Opcode
{
return
opcode
.
I32DivS
}
internal/3rdparty/wasm/instruction/parametric.go
0 → 100644
浏览文件 @
86cc8a40
// Copyright 2021 The OPA Authors. All rights reserved.
// Use of this source code is governed by an Apache2
// license that can be found in the LICENSE file.
package
instruction
import
(
"github.com/wa-lang/wa/internal/3rdparty/wasm/opcode"
)
// Drop reprsents a WASM drop instruction.
type
Drop
struct
{
NoImmediateArgs
}
// Op returns the opcode of the instruction.
func
(
Drop
)
Op
()
opcode
.
Opcode
{
return
opcode
.
Drop
}
// Select reprsents a WASM select instruction.
type
Select
struct
{
NoImmediateArgs
}
// Op returns the opcode of the instruction.
func
(
Select
)
Op
()
opcode
.
Opcode
{
return
opcode
.
Select
}
internal/3rdparty/wasm/instruction/variable.go
0 → 100644
浏览文件 @
86cc8a40
// Copyright 2018 The OPA Authors. All rights reserved.
// Use of this source code is governed by an Apache2
// license that can be found in the LICENSE file.
package
instruction
import
"github.com/wa-lang/wa/internal/3rdparty/wasm/opcode"
// GetLocal represents the WASM get_local instruction.
type
GetLocal
struct
{
Index
uint32
}
// Op returns the opcode of the instruction.
func
(
GetLocal
)
Op
()
opcode
.
Opcode
{
return
opcode
.
GetLocal
}
// ImmediateArgs returns the index of the local variable to push onto the stack.
func
(
i
GetLocal
)
ImmediateArgs
()
[]
interface
{}
{
return
[]
interface
{}{
i
.
Index
}
}
// SetLocal represents the WASM set_local instruction.
type
SetLocal
struct
{
Index
uint32
}
// Op returns the opcode of the instruction.
func
(
SetLocal
)
Op
()
opcode
.
Opcode
{
return
opcode
.
SetLocal
}
// ImmediateArgs returns the index of the local variable to set with the top of
// the stack.
func
(
i
SetLocal
)
ImmediateArgs
()
[]
interface
{}
{
return
[]
interface
{}{
i
.
Index
}
}
// TeeLocal represents the WASM tee_local instruction.
type
TeeLocal
struct
{
Index
uint32
}
// Op returns the opcode of the instruction.
func
(
TeeLocal
)
Op
()
opcode
.
Opcode
{
return
opcode
.
TeeLocal
}
// ImmediateArgs returns the index of the local variable to "tee" with the top of
// the stack (like set, but retaining the top of the stack).
func
(
i
TeeLocal
)
ImmediateArgs
()
[]
interface
{}
{
return
[]
interface
{}{
i
.
Index
}
}
type
GetGlobal
struct
{
Index
uint32
}
func
(
GetGlobal
)
Op
()
opcode
.
Opcode
{
return
opcode
.
GetGlobal
}
func
(
i
GetGlobal
)
ImmediateArgs
()
[]
interface
{}
{
return
[]
interface
{}{
i
.
Index
}
}
type
SetGlobal
struct
{
Index
uint32
}
func
(
SetGlobal
)
Op
()
opcode
.
Opcode
{
return
opcode
.
SetGlobal
}
func
(
i
SetGlobal
)
ImmediateArgs
()
[]
interface
{}
{
return
[]
interface
{}{
i
.
Index
}
}
internal/3rdparty/wasm/leb128/leb128.go
0 → 100644
浏览文件 @
86cc8a40
// Copyright 2018 The OPA Authors. All rights reserved.
// Use of this source code is governed by an Apache2
// license that can be found in the LICENSE file.
// Package leb128 implements LEB128 integer encoding.
package
leb128
import
(
"io"
)
// MustReadVarInt32 returns an int32 from r or panics.
func
MustReadVarInt32
(
r
io
.
Reader
)
int32
{
i32
,
err
:=
ReadVarInt32
(
r
)
if
err
!=
nil
{
panic
(
err
)
}
return
i32
}
// MustReadVarInt64 returns an int64 from r or panics.
func
MustReadVarInt64
(
r
io
.
Reader
)
int64
{
i64
,
err
:=
ReadVarInt64
(
r
)
if
err
!=
nil
{
panic
(
err
)
}
return
i64
}
// MustReadVarUint32 returns an uint32 from r or panics.
func
MustReadVarUint32
(
r
io
.
Reader
)
uint32
{
u32
,
err
:=
ReadVarUint32
(
r
)
if
err
!=
nil
{
panic
(
err
)
}
return
u32
}
// MustReadVarUint64 returns an uint64 from r or panics.
func
MustReadVarUint64
(
r
io
.
Reader
)
uint64
{
u64
,
err
:=
ReadVarUint64
(
r
)
if
err
!=
nil
{
panic
(
err
)
}
return
u64
}
// Copied rom http://dwarfstd.org/doc/Dwarf3.pdf.
// ReadVarUint32 tries to read a uint32 from r.
func
ReadVarUint32
(
r
io
.
Reader
)
(
uint32
,
error
)
{
u64
,
err
:=
ReadVarUint64
(
r
)
if
err
!=
nil
{
return
0
,
err
}
return
uint32
(
u64
),
nil
}
// ReadVarUint64 tries to read a uint64 from r.
func
ReadVarUint64
(
r
io
.
Reader
)
(
uint64
,
error
)
{
var
result
uint64
var
shift
uint64
buf
:=
make
([]
byte
,
1
)
for
{
if
_
,
err
:=
r
.
Read
(
buf
);
err
!=
nil
{
return
0
,
err
}
v
:=
uint64
(
buf
[
0
])
result
|=
(
v
&
0x7F
)
<<
shift
if
v
&
0x80
==
0
{
return
result
,
nil
}
shift
+=
7
}
}
// ReadVarInt32 tries to read a int32 from r.
func
ReadVarInt32
(
r
io
.
Reader
)
(
int32
,
error
)
{
i64
,
err
:=
ReadVarInt64
(
r
)
if
err
!=
nil
{
return
0
,
err
}
return
int32
(
i64
),
nil
}
// ReadVarInt64 tries to read a int64 from r.
func
ReadVarInt64
(
r
io
.
Reader
)
(
int64
,
error
)
{
var
result
int64
var
shift
uint64
size
:=
uint64
(
32
)
buf
:=
make
([]
byte
,
1
)
for
{
if
_
,
err
:=
r
.
Read
(
buf
);
err
!=
nil
{
return
0
,
err
}
v
:=
int64
(
buf
[
0
])
result
|=
(
v
&
0x7F
)
<<
shift
shift
+=
7
if
v
&
0x80
==
0
{
if
(
shift
<
size
)
&&
(
v
&
0x40
!=
0
)
{
result
|=
(
^
0
<<
shift
)
}
return
result
,
nil
}
}
}
// WriteVarUint32 writes u to w.
func
WriteVarUint32
(
w
io
.
Writer
,
u
uint32
)
error
{
var
b
[]
byte
_
,
err
:=
w
.
Write
(
appendUleb128
(
b
,
uint64
(
u
)))
return
err
}
// WriteVarUint64 writes u to w.
func
WriteVarUint64
(
w
io
.
Writer
,
u
uint64
)
error
{
var
b
[]
byte
_
,
err
:=
w
.
Write
(
appendUleb128
(
b
,
u
))
return
err
}
// WriteVarInt32 writes u to w.
func
WriteVarInt32
(
w
io
.
Writer
,
i
int32
)
error
{
var
b
[]
byte
_
,
err
:=
w
.
Write
(
appendSleb128
(
b
,
int64
(
i
)))
return
err
}
// WriteVarInt64 writes u to w.
func
WriteVarInt64
(
w
io
.
Writer
,
i
int64
)
error
{
var
b
[]
byte
_
,
err
:=
w
.
Write
(
appendSleb128
(
b
,
i
))
return
err
}
// Copied from https://github.com/golang/go/blob/master/src/cmd/internal/dwarf/dwarf.go.
// appendUleb128 appends v to b using DWARF's unsigned LEB128 encoding.
func
appendUleb128
(
b
[]
byte
,
v
uint64
)
[]
byte
{
for
{
c
:=
uint8
(
v
&
0x7f
)
v
>>=
7
if
v
!=
0
{
c
|=
0x80
}
b
=
append
(
b
,
c
)
if
c
&
0x80
==
0
{
break
}
}
return
b
}
// appendSleb128 appends v to b using DWARF's signed LEB128 encoding.
func
appendSleb128
(
b
[]
byte
,
v
int64
)
[]
byte
{
for
{
c
:=
uint8
(
v
&
0x7f
)
s
:=
uint8
(
v
&
0x40
)
v
>>=
7
if
(
v
!=
-
1
||
s
==
0
)
&&
(
v
!=
0
||
s
!=
0
)
{
c
|=
0x80
}
b
=
append
(
b
,
c
)
if
c
&
0x80
==
0
{
break
}
}
return
b
}
internal/3rdparty/wasm/leb128/leb128_test.go
0 → 100644
浏览文件 @
86cc8a40
// Copyright 2018 The OPA Authors. All rights reserved.
// Use of this source code is governed by an Apache2
// license that can be found in the LICENSE file.
package
leb128
import
(
"bytes"
"testing"
)
// Test cases copied from http://dwarfstd.org/doc/Dwarf3.pdf.
func
TestReadVarUint64
(
t
*
testing
.
T
)
{
tests
:=
[]
struct
{
bs
[]
byte
exp
uint64
}{
{
bs
:
[]
byte
(
"
\x02
"
),
exp
:
2
,
},
{
bs
:
[]
byte
(
"
\x7F
"
),
exp
:
127
,
},
{
bs
:
[]
byte
(
"
\x80\x01
"
),
exp
:
128
,
},
{
bs
:
[]
byte
(
"
\x81\x01
"
),
exp
:
129
,
},
{
bs
:
[]
byte
(
"
\x82\x01
"
),
exp
:
130
,
},
{
bs
:
[]
byte
(
"
\xB9\x64
"
),
exp
:
12857
,
},
}
for
i
,
tc
:=
range
tests
{
r
:=
bytes
.
NewReader
(
tc
.
bs
)
result
,
err
:=
ReadVarUint64
(
r
)
if
err
!=
nil
{
t
.
Fatalf
(
"Case %d, err: %v"
,
i
,
err
)
}
else
if
result
!=
tc
.
exp
{
t
.
Fatalf
(
"Case %d, expected %v, but got %v"
,
i
,
tc
.
exp
,
result
)
}
}
}
func
TestReadVarInt64
(
t
*
testing
.
T
)
{
tests
:=
[]
struct
{
bs
[]
byte
exp
int64
}{
{
bs
:
[]
byte
(
"
\x02
"
),
exp
:
2
,
},
{
bs
:
[]
byte
(
"
\x7E
"
),
exp
:
-
2
,
},
{
bs
:
[]
byte
(
"
\xFF\x00
"
),
exp
:
127
,
},
{
bs
:
[]
byte
(
"
\x81\x7F
"
),
exp
:
-
127
,
},
{
bs
:
[]
byte
(
"
\x80\x01
"
),
exp
:
128
,
},
{
bs
:
[]
byte
(
"
\x80\x7F
"
),
exp
:
-
128
,
},
{
bs
:
[]
byte
(
"
\x81\x01
"
),
exp
:
129
,
},
{
bs
:
[]
byte
(
"
\xFF\x7E
"
),
exp
:
-
129
,
},
}
for
i
,
tc
:=
range
tests
{
r
:=
bytes
.
NewReader
(
tc
.
bs
)
result
,
err
:=
ReadVarInt64
(
r
)
if
err
!=
nil
{
t
.
Fatalf
(
"Case %d, err: %v"
,
i
,
err
)
}
else
if
result
!=
tc
.
exp
{
t
.
Fatalf
(
"Case %d, expected %v, but got %v"
,
i
,
tc
.
exp
,
result
)
}
}
}
func
TestWriteVarUint64
(
t
*
testing
.
T
)
{
tests
:=
[]
struct
{
bs
[]
byte
input
uint64
}{
{
bs
:
[]
byte
(
"
\x02
"
),
input
:
2
,
},
{
bs
:
[]
byte
(
"
\x7F
"
),
input
:
127
,
},
{
bs
:
[]
byte
(
"
\x80\x01
"
),
input
:
128
,
},
{
bs
:
[]
byte
(
"
\x81\x01
"
),
input
:
129
,
},
{
bs
:
[]
byte
(
"
\x82\x01
"
),
input
:
130
,
},
{
bs
:
[]
byte
(
"
\xB9\x64
"
),
input
:
12857
,
},
}
for
i
,
tc
:=
range
tests
{
var
buf
bytes
.
Buffer
if
err
:=
WriteVarUint64
(
&
buf
,
tc
.
input
);
err
!=
nil
{
t
.
Fatalf
(
"Case %d, err: %v"
,
i
,
err
)
}
if
!
bytes
.
Equal
(
buf
.
Bytes
(),
tc
.
bs
)
{
t
.
Fatalf
(
"Case %d, expected %v, but got %v"
,
i
,
tc
.
bs
,
buf
.
Bytes
())
}
}
}
func
TestWriteVarInt64
(
t
*
testing
.
T
)
{
tests
:=
[]
struct
{
bs
[]
byte
input
int64
}{
{
bs
:
[]
byte
(
"
\x02
"
),
input
:
2
,
},
{
bs
:
[]
byte
(
"
\x7E
"
),
input
:
-
2
,
},
{
bs
:
[]
byte
(
"
\xFF\x00
"
),
input
:
127
,
},
{
bs
:
[]
byte
(
"
\x81\x7F
"
),
input
:
-
127
,
},
{
bs
:
[]
byte
(
"
\x80\x01
"
),
input
:
128
,
},
{
bs
:
[]
byte
(
"
\x80\x7F
"
),
input
:
-
128
,
},
{
bs
:
[]
byte
(
"
\x81\x01
"
),
input
:
129
,
},
{
bs
:
[]
byte
(
"
\xFF\x7E
"
),
input
:
-
129
,
},
}
for
i
,
tc
:=
range
tests
{
var
buf
bytes
.
Buffer
if
err
:=
WriteVarInt64
(
&
buf
,
tc
.
input
);
err
!=
nil
{
t
.
Fatalf
(
"Case %d, err: %v"
,
i
,
err
)
}
if
!
bytes
.
Equal
(
buf
.
Bytes
(),
tc
.
bs
)
{
t
.
Fatalf
(
"Case %d, expected %v, but got %v"
,
i
,
tc
.
bs
,
buf
.
Bytes
())
}
}
}
internal/3rdparty/wasm/module/module.go
0 → 100644
浏览文件 @
86cc8a40
// Copyright 2018 The OPA Authors. All rights reserved.
// Use of this source code is governed by an Apache2
// license that can be found in the LICENSE file.
package
module
import
(
"fmt"
"strings"
"github.com/wa-lang/wa/internal/3rdparty/wasm/instruction"
"github.com/wa-lang/wa/internal/3rdparty/wasm/types"
)
type
(
// Module represents a WASM module.
Module
struct
{
Version
uint32
Start
StartSection
Type
TypeSection
Import
ImportSection
Function
FunctionSection
Table
TableSection
Memory
MemorySection
Element
ElementSection
Global
GlobalSection
Export
ExportSection
Code
RawCodeSection
Data
DataSection
Customs
[]
CustomSection
Names
NameSection
}
// StartSection represents a WASM start section.
StartSection
struct
{
FuncIndex
*
uint32
}
// TypeSection represents a WASM type section.
TypeSection
struct
{
Functions
[]
FunctionType
}
// ImportSection represents a WASM import section.
ImportSection
struct
{
Imports
[]
Import
}
// FunctionSection represents a WASM function section.
FunctionSection
struct
{
TypeIndices
[]
uint32
}
// TableSection represents a WASM table section.
TableSection
struct
{
Tables
[]
Table
}
// MemorySection represents a WASM memory section.
MemorySection
struct
{
Memorys
[]
Memory
}
// ElementSection represents a WASM element section.
ElementSection
struct
{
Segments
[]
ElementSegment
}
// GlobalSection represents a WASM global section.
GlobalSection
struct
{
Globals
[]
Global
}
// ExportSection represents a WASM export section.
ExportSection
struct
{
Exports
[]
Export
}
// RawCodeSection represents a WASM code section. The code section is left as a
// raw byte sequence.
RawCodeSection
struct
{
Segments
[]
RawCodeSegment
}
// DataSection represents a WASM data section.
DataSection
struct
{
Segments
[]
DataSegment
}
// CustomSection represents a WASM custom section.
CustomSection
struct
{
Name
string
Data
[]
byte
}
// NameSection represents the WASM custom section "name".
NameSection
struct
{
Module
string
Functions
[]
NameMap
Locals
[]
LocalNameMap
}
Memory
struct
{
InitPages
uint32
MaxPages
uint32
}
// NameMap maps function or local arg indices to their names.
NameMap
struct
{
Index
uint32
Name
string
}
// LocalNameMap maps function indices, and argument indices for the args
// of the indexed function to their names.
LocalNameMap
struct
{
FuncIndex
uint32
NameMap
}
// FunctionType represents a WASM function type definition.
FunctionType
struct
{
Params
[]
types
.
ValueType
Results
[]
types
.
ValueType
}
// Import represents a WASM import statement.
Import
struct
{
Module
string
Name
string
Descriptor
ImportDescriptor
}
// ImportDescriptor represents a WASM import descriptor.
ImportDescriptor
interface
{
fmt
.
Stringer
Kind
()
ImportDescriptorType
}
// ImportDescriptorType defines allowed kinds of import descriptors.
ImportDescriptorType
int
// FunctionImport represents a WASM function import statement.
FunctionImport
struct
{
Func
uint32
}
// MemoryImport represents a WASM memory import statement.
MemoryImport
struct
{
Mem
MemType
}
// MemType defines the attributes of a memory import.
MemType
struct
{
Lim
Limit
}
// TableImport represents a WASM table import statement.
TableImport
struct
{
Type
types
.
ElementType
Lim
Limit
}
// ElementSegment represents a WASM element segment.
ElementSegment
struct
{
Index
uint32
Offset
Expr
Indices
[]
uint32
}
// GlobalImport represents a WASM global variable import statement.
GlobalImport
struct
{
Type
types
.
ValueType
Mutable
bool
}
// Limit represents a WASM limit.
Limit
struct
{
Min
uint32
Max
*
uint32
}
// Table represents a WASM table statement.
Table
struct
{
Type
types
.
ElementType
Lim
Limit
}
// Global represents a WASM global statement.
Global
struct
{
Type
types
.
ValueType
Mutable
bool
Init
Expr
}
// Export represents a WASM export statement.
Export
struct
{
Name
string
Descriptor
ExportDescriptor
}
// ExportDescriptor represents a WASM export descriptor.
ExportDescriptor
struct
{
Type
ExportDescriptorType
Index
uint32
}
// ExportDescriptorType defines the allowed kinds of export descriptors.
ExportDescriptorType
int
// RawCodeSegment represents a binary-encoded WASM code segment.
RawCodeSegment
struct
{
Code
[]
byte
}
// DataSegment represents a WASM data segment.
DataSegment
struct
{
Index
uint32
Offset
Expr
Init
[]
byte
}
// Expr represents a WASM expression.
Expr
struct
{
Instrs
[]
instruction
.
Instruction
}
// CodeEntry represents a code segment entry.
CodeEntry
struct
{
Func
Function
}
// Function represents a function in a code segment.
Function
struct
{
Locals
[]
LocalDeclaration
Expr
Expr
}
// LocalDeclaration represents a local variable declaration.
LocalDeclaration
struct
{
Count
uint32
Type
types
.
ValueType
}
)
// Defines the allowed kinds of imports.
const
(
FunctionImportType
ImportDescriptorType
=
iota
TableImportType
MemoryImportType
GlobalImportType
)
func
(
x
ImportDescriptorType
)
String
()
string
{
switch
x
{
case
FunctionImportType
:
return
"func"
case
TableImportType
:
return
"table"
case
MemoryImportType
:
return
"memory"
case
GlobalImportType
:
return
"global"
}
panic
(
"illegal value"
)
}
// Defines the allowed kinds of exports.
const
(
FunctionExportType
ExportDescriptorType
=
iota
TableExportType
MemoryExportType
GlobalExportType
)
func
(
x
ExportDescriptorType
)
String
()
string
{
switch
x
{
case
FunctionExportType
:
return
"func"
case
TableExportType
:
return
"table"
case
MemoryExportType
:
return
"memory"
case
GlobalExportType
:
return
"global"
}
panic
(
"illegal value"
)
}
// Kind returns the function import type kind.
func
(
i
FunctionImport
)
Kind
()
ImportDescriptorType
{
return
FunctionImportType
}
func
(
i
FunctionImport
)
String
()
string
{
return
fmt
.
Sprintf
(
"%v[type=%v]"
,
i
.
Kind
(),
i
.
Func
)
}
// Kind returns the memory import type kind.
func
(
i
MemoryImport
)
Kind
()
ImportDescriptorType
{
return
MemoryImportType
}
func
(
i
MemoryImport
)
String
()
string
{
return
fmt
.
Sprintf
(
"%v[%v]"
,
i
.
Kind
(),
i
.
Mem
.
Lim
)
}
// Kind returns the table import type kind.
func
(
i
TableImport
)
Kind
()
ImportDescriptorType
{
return
TableImportType
}
func
(
i
TableImport
)
String
()
string
{
return
fmt
.
Sprintf
(
"%v[%v, %v]"
,
i
.
Kind
(),
i
.
Type
,
i
.
Lim
)
}
// Kind returns the global import type kind.
func
(
i
GlobalImport
)
Kind
()
ImportDescriptorType
{
return
GlobalImportType
}
func
(
i
GlobalImport
)
String
()
string
{
return
fmt
.
Sprintf
(
"%v[%v, mut=%v]"
,
i
.
Kind
(),
i
.
Type
,
i
.
Mutable
)
}
func
(
tpe
FunctionType
)
String
()
string
{
params
:=
make
([]
string
,
len
(
tpe
.
Params
))
results
:=
make
([]
string
,
len
(
tpe
.
Results
))
for
i
:=
range
tpe
.
Params
{
params
[
i
]
=
tpe
.
Params
[
i
]
.
String
()
}
for
i
:=
range
tpe
.
Results
{
results
[
i
]
=
tpe
.
Results
[
i
]
.
String
()
}
return
"("
+
strings
.
Join
(
params
,
", "
)
+
") -> ("
+
strings
.
Join
(
results
,
", "
)
+
")"
}
// Equal returns true if tpe equals other.
func
(
tpe
FunctionType
)
Equal
(
other
FunctionType
)
bool
{
if
len
(
tpe
.
Params
)
!=
len
(
other
.
Params
)
||
len
(
tpe
.
Results
)
!=
len
(
other
.
Results
)
{
return
false
}
for
i
:=
range
tpe
.
Params
{
if
tpe
.
Params
[
i
]
!=
other
.
Params
[
i
]
{
return
false
}
}
for
i
:=
range
tpe
.
Results
{
if
tpe
.
Results
[
i
]
!=
other
.
Results
[
i
]
{
return
false
}
}
return
true
}
func
(
imp
Import
)
String
()
string
{
return
fmt
.
Sprintf
(
"%v %v.%v"
,
imp
.
Descriptor
.
String
(),
imp
.
Module
,
imp
.
Name
)
}
func
(
exp
Export
)
String
()
string
{
return
fmt
.
Sprintf
(
"%v[%v] %v"
,
exp
.
Descriptor
.
Type
,
exp
.
Descriptor
.
Index
,
exp
.
Name
)
}
func
(
seg
RawCodeSegment
)
String
()
string
{
return
fmt
.
Sprintf
(
"<code %d bytes>"
,
len
(
seg
.
Code
))
}
func
(
seg
DataSegment
)
String
()
string
{
return
fmt
.
Sprintf
(
"<data index=%v [%v] len=%d bytes>"
,
seg
.
Index
,
seg
.
Offset
,
len
(
seg
.
Init
))
}
func
(
e
Expr
)
String
()
string
{
return
fmt
.
Sprintf
(
"%d instr(s)"
,
len
(
e
.
Instrs
))
}
func
(
lim
Limit
)
String
()
string
{
if
lim
.
Max
==
nil
{
return
fmt
.
Sprintf
(
"min=%v"
,
lim
.
Min
)
}
return
fmt
.
Sprintf
(
"min=%v max=%v"
,
lim
.
Min
,
lim
.
Max
)
}
internal/3rdparty/wasm/module/pretty.go
0 → 100644
浏览文件 @
86cc8a40
// Copyright 2018 The OPA Authors. All rights reserved.
// Use of this source code is governed by an Apache2
// license that can be found in the LICENSE file.
package
module
import
(
"encoding/hex"
"fmt"
"io"
)
// PrettyOption defines options for controlling pretty printing.
type
PrettyOption
struct
{
Contents
bool
// show raw byte content of data+code sections.
}
// Pretty writes a human-readable representation of m to w.
func
Pretty
(
w
io
.
Writer
,
m
*
Module
,
opts
...
PrettyOption
)
{
fmt
.
Fprintln
(
w
,
"version:"
,
m
.
Version
)
fmt
.
Fprintln
(
w
,
"types:"
)
for
_
,
fn
:=
range
m
.
Type
.
Functions
{
fmt
.
Fprintln
(
w
,
" -"
,
fn
)
}
fmt
.
Fprintln
(
w
,
"imports:"
)
for
i
,
imp
:=
range
m
.
Import
.
Imports
{
if
imp
.
Descriptor
.
Kind
()
==
FunctionImportType
{
fmt
.
Printf
(
" - [%d] %v
\n
"
,
i
,
imp
)
}
else
{
fmt
.
Fprintln
(
w
,
" -"
,
imp
)
}
}
fmt
.
Fprintln
(
w
,
"functions:"
)
for
_
,
fn
:=
range
m
.
Function
.
TypeIndices
{
if
fn
>=
uint32
(
len
(
m
.
Type
.
Functions
))
{
fmt
.
Fprintln
(
w
,
" -"
,
"???"
)
}
else
{
fmt
.
Fprintln
(
w
,
" -"
,
m
.
Type
.
Functions
[
fn
])
}
}
fmt
.
Fprintln
(
w
,
"exports:"
)
for
_
,
exp
:=
range
m
.
Export
.
Exports
{
fmt
.
Fprintln
(
w
,
" -"
,
exp
)
}
fmt
.
Fprintln
(
w
,
"code:"
)
for
_
,
seg
:=
range
m
.
Code
.
Segments
{
fmt
.
Fprintln
(
w
,
" -"
,
seg
)
}
fmt
.
Fprintln
(
w
,
"data:"
)
for
_
,
seg
:=
range
m
.
Data
.
Segments
{
fmt
.
Fprintln
(
w
,
" -"
,
seg
)
}
if
len
(
opts
)
==
0
{
return
}
fmt
.
Fprintln
(
w
)
for
_
,
opt
:=
range
opts
{
if
opt
.
Contents
{
newline
:=
false
if
len
(
m
.
Data
.
Segments
)
>
0
{
fmt
.
Fprintln
(
w
,
"data section:"
)
for
_
,
seg
:=
range
m
.
Data
.
Segments
{
if
newline
{
fmt
.
Fprintln
(
w
)
}
fmt
.
Fprintln
(
w
,
hex
.
Dump
(
seg
.
Init
))
newline
=
true
}
newline
=
false
}
if
len
(
m
.
Code
.
Segments
)
>
0
{
fmt
.
Fprintln
(
w
,
"code section:"
)
for
_
,
seg
:=
range
m
.
Code
.
Segments
{
if
newline
{
fmt
.
Fprintln
(
w
)
}
fmt
.
Fprintln
(
w
,
hex
.
Dump
(
seg
.
Code
))
newline
=
true
}
newline
=
false
}
}
}
}
internal/3rdparty/wasm/opcode/opcode.go
0 → 100644
浏览文件 @
86cc8a40
// Copyright 2018 The OPA Authors. All rights reserved.
// Use of this source code is governed by an Apache2
// license that can be found in the LICENSE file.
// Package opcode contains constants and utilities for working with WASM opcodes.
package
opcode
// Opcode represents a WASM instruction opcode.
type
Opcode
byte
// Control instructions.
const
(
Unreachable
Opcode
=
iota
Nop
Block
Loop
If
Else
)
const
(
// End defines the special end WASM opcode.
End
Opcode
=
0x0B
)
// Extended control instructions.
const
(
Br
Opcode
=
iota
+
0x0C
BrIf
BrTable
Return
Call
CallIndirect
)
// Parameter instructions.
const
(
Drop
Opcode
=
iota
+
0x1A
Select
)
// Variable instructions.
const
(
GetLocal
Opcode
=
iota
+
0x20
SetLocal
TeeLocal
GetGlobal
SetGlobal
)
// Memory instructions.
const
(
I32Load
Opcode
=
iota
+
0x28
I64Load
F32Load
F64Load
I32Load8S
I32Load8U
I32Load16S
I32Load16U
I64Load8S
I64Load8U
I64Load16S
I64Load16U
I64Load32S
I64Load32U
I32Store
I64Store
F32Store
F64Store
I32Store8
I32Store16
I64Store8
I64Store16
I64Store32
MemorySize
MemoryGrow
)
// Numeric instructions.
const
(
I32Const
Opcode
=
iota
+
0x41
I64Const
F32Const
F64Const
I32Eqz
I32Eq
I32Ne
I32LtS
I32LtU
I32GtS
I32GtU
I32LeS
I32LeU
I32GeS
I32GeU
I64Eqz
I64Eq
I64Ne
I64LtS
I64LtU
I64GtS
I64GtU
I64LeS
I64LeU
I64GeS
I64GeU
F32Eq
F32Ne
F32Lt
F32Gt
F32Le
F32Ge
F64Eq
F64Ne
F64Lt
F64Gt
F64Le
F64Ge
I32Clz
I32Ctz
I32Popcnt
I32Add
I32Sub
I32Mul
I32DivS
I32DivU
I32RemS
I32RemU
I32And
I32Or
I32Xor
I32Shl
I32ShrS
I32ShrU
I32Rotl
I32Rotr
I64Clz
I64Ctz
I64Popcnt
I64Add
I64Sub
I64Mul
I64DivS
I64DivU
I64RemS
I64RemU
I64And
I64Or
I64Xor
I64Shl
I64ShrS
I64ShrU
I64Rotl
I64Rotr
F32Abs
F32Neg
F32Ceil
F32Floor
F32Trunc
F32Nearest
F32Sqrt
F32Add
F32Sub
F32Mul
F32Div
F32Min
F32Max
F32Copysign
F64Abs
F64Neg
F64Ceil
F64Floor
F64Trunc
F64Nearest
F64Sqrt
F64Add
F64Sub
F64Mul
F64Div
F64Min
F64Max
F64Copysign
I32WrapI64
I32TruncSF32
I32TruncUF32
I32TruncSF64
I32TruncUF64
I64ExtendSI32
I64ExtendUI32
I64TruncSF32
I64TruncUF32
I64TruncSF64
I64TruncUF64
F32ConvertSI32
F32ConvertUI32
F32ConvertSI64
F32ConvertUI64
F32DemoteF64
F64ConvertSI32
F64ConvertUI32
F64ConvertSI64
F64ConvertUI64
F64PromoteF32
I32ReinterpretF32
I64ReinterpretF64
F32ReinterpretI32
F64ReinterpretI64
)
internal/3rdparty/wasm/types/types.go
0 → 100644
浏览文件 @
86cc8a40
// Copyright 2018 The OPA Authors. All rights reserved.
// Use of this source code is governed by an Apache2
// license that can be found in the LICENSE file.
// Package types defines the WASM value type constants.
package
types
// ValueType represents an intrinsic value in WASM.
type
ValueType
int
// Defines the intrinsic value types.
const
(
I32
ValueType
=
iota
I64
F32
F64
)
func
(
tpe
ValueType
)
String
()
string
{
if
tpe
==
I32
{
return
"i32"
}
else
if
tpe
==
I64
{
return
"i64"
}
else
if
tpe
==
F32
{
return
"f32"
}
return
"f64"
}
// ElementType defines the type of table elements.
type
ElementType
int
const
(
// Anyfunc is the union of all table types.
Anyfunc
ElementType
=
iota
)
编辑
预览
Markdown
is supported
0%
请重试
或
添加新附件
.
添加附件
取消
You are about to add
0
people
to the discussion. Proceed with caution.
先完成此消息的编辑!
取消
想要评论请
注册
或
登录