func (uls UnknownLoaders) Load(r reader.Reader, payloadLen uint32) (err error) { defer func() { err = errutil.ErrorOrPanic(recover()) }() load := loader.L{r} nameLen := load.Varuint32() if nameLen > maxSectionNameLen { panic(errors.New("unknown section name is too long")) } name := string(load.Bytes(nameLen)) if f := uls[name]; f != nil { if err := f(name, load); err != nil { panic(err) } } else { if _, err := io.CopyN(ioutil.Discard, load, int64(payloadLen)); err != nil { panic(err) } } return }
func (ns *NameSection) Load(_ string, r reader.Reader) (err error) { defer func() { err = errutil.ErrorOrPanic(recover()) }() load := loader.L{r} count := load.Varuint32() ns.FunctionNames = make([]FunctionName, count) for i := range ns.FunctionNames { fn := &ns.FunctionNames[i] funNameLen := load.Varuint32() fn.FunName = string(load.Bytes(funNameLen)) localCount := load.Varuint32() fn.LocalNames = make([]string, localCount) for j := range fn.LocalNames { localNameLen := load.Varuint32() fn.LocalNames[j] = string(load.Bytes(localNameLen)) } } return }
func (m *Module) genData(load loader.L) { if debug { debugf("data section") debugDepth++ } if m.memoryOffset&15 != 0 { // not 16-byte aligned? (assume at least 8-byte alignment.) n := len(m.globals) m.globals = append(m.globals, global{}) m.data = appendGlobalsData(m.data, m.globals[n:]) m.memoryOffset = len(m.data) } for i := range load.Count() { if debug { debugf("data segment") debugDepth++ } if index := load.Varuint32(); index != 0 { panic(fmt.Errorf("unsupported memory index: %d", index)) } offset := readOffsetInitExpr(load, m) size := load.Varuint32() needMemorySize := int64(offset) + int64(size) if needMemorySize >= int64(m.memoryLimits.initial) { panic(fmt.Errorf("memory segment #%d exceeds initial memory size", i)) } needDataSize := int64(m.memoryOffset) + needMemorySize if needDataSize > int64(len(m.data)) { if int64(cap(m.data)) >= needDataSize { m.data = m.data[:needDataSize] } else { buf := make([]byte, needDataSize) copy(buf, m.data) m.data = buf } } dataOffset := m.memoryOffset + int(offset) load.Into(m.data[dataOffset:needDataSize]) if debug { debugDepth-- debugf("data segmented: offset=0x%x size=0x%x", offset, size) } } if debug { debugDepth-- debugf("data sectioned") } }
func readSectionHeader(load loader.L, expectId byte, idError string) (ok bool) { id, err := load.ReadByte() if err != nil { if err == io.EOF { return } panic(err) } if id != expectId { panic(errors.New(idError)) } load.Varuint32() // payload len ok = true return }
func copySection(w io.Writer, r reader.Reader, expectId byte) (ok bool) { store := storer{w} load := loader.L{Reader: r} loop: for { id, err := load.ReadByte() if err != nil { if err == io.EOF { return } panic(err) } switch { case id == sectionids.Unknown: payloadLen := load.Varuint32() if _, err := io.CopyN(ioutil.Discard, load, int64(payloadLen)); err != nil { panic(err) } case id == expectId: store.Byte(id) break loop default: load.UnreadByte() return } } payloadLen := load.Varuint32() store.Varuint32(payloadLen) if _, err := io.CopyN(store, load, int64(payloadLen)); err != nil { panic(err) } ok = true return }
func readInitExpr(load loader.L, m *Module) (valueBits uint64, t types.T) { op := opcode(load.Byte()) switch op { case opcodeI32Const: valueBits = uint64(int64(load.Varint32())) t = types.I32 case opcodeI64Const: valueBits = uint64(load.Varint64()) t = types.I64 case opcodeF32Const: valueBits = uint64(load.Uint32()) t = types.F32 case opcodeF64Const: valueBits = load.Uint64() t = types.F64 case opcodeGetGlobal: i := load.Varuint32() if i >= uint32(m.numImportGlobals) { panic(fmt.Errorf("import global index out of bounds in initializer expression: %d", i)) } g := m.globals[i] valueBits = g.init t = g.t default: panic(fmt.Errorf("unsupported operation in initializer expression: %s", op)) } if op := opcode(load.Byte()); op != opcodeEnd { panic(fmt.Errorf("unexpected operation in initializer expression when expecting end: %s", op)) } return }
func readResizableLimits(load loader.L, maxInitial, maxMaximum uint32, scale int) resizableLimits { flags := load.Varuint32() initial := load.Varuint32() if initial > maxInitial { panic(fmt.Errorf("initial memory size is too large: %d", initial)) } maximum := maxMaximum if (flags & resizableLimitsFlagMaximum) != 0 { maximum = load.Varuint32() if maximum > maxMaximum { maximum = maxMaximum } if maximum < initial { panic(fmt.Errorf("maximum memory size %d is smaller than initial memory size %d", maximum, initial)) } } return resizableLimits{int(initial) * scale, int(maximum) * scale, true} }
func (m moduleLoader) loadUntil(load loader.L, untilSection byte) byte { var header struct { MagicNumber uint32 Version uint32 } if err := binary.Read(load, binary.LittleEndian, &header); err != nil { panic(err) } if header.MagicNumber != moduleMagicNumber { panic(errors.New("not a WebAssembly module")) } if header.Version != moduleVersion { panic(fmt.Errorf("unsupported module version: %d", header.Version)) } var skipSection func(byte, uint32) error if m.UnknownSectionLoader != nil { skipSection = func(id byte, payloadLen uint32) (err error) { if id == sectionids.Unknown { err = m.UnknownSectionLoader(load, payloadLen) } else { _, err = io.CopyN(ioutil.Discard, load, int64(payloadLen)) } return } } else { skipSection = func(id byte, payloadLen uint32) (err error) { _, err = io.CopyN(ioutil.Discard, load, int64(payloadLen)) return } } var seenId byte for { id, err := load.ReadByte() if err != nil { if err == io.EOF { return 0 } panic(err) } if id != sectionids.Unknown { if id <= seenId { panic(fmt.Errorf("section 0x%x follows section 0x%x", id, seenId)) } seenId = id } if id >= untilSection { load.UnreadByte() return id } payloadLen := load.Varuint32() if f := sectionLoaders[id]; f != nil { f(m, load) } else if err := skipSection(id, payloadLen); err != nil { panic(err) } } }