Golang loader.L类代码示例

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 (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 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 (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 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)
		}
	}
}

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
}