src/cmd/link/internal/wasm/asm.go

   1 // Copyright 2018 The Go Authors. All rights reserved.
   2 // Use of this source code is governed by a BSD-style
   3 // license that can be found in the LICENSE file.
   4
   5 package wasm
   6
   7 import (
   8         "bytes"
   9         "cmd/internal/objabi"
  10         "cmd/link/internal/ld"
  11         "cmd/link/internal/loader"
  12         "cmd/link/internal/sym"
  13         "internal/buildcfg"
  14         "io"
  15         "regexp"
  16 )
  17
  18 const (
  19         I32 = 0x7F
  20         I64 = 0x7E
  21         F32 = 0x7D
  22         F64 = 0x7C
  23 )
  24
  25 const (
  26         sectionCustom   = 0
  27         sectionType     = 1
  28         sectionImport   = 2
  29         sectionFunction = 3
  30         sectionTable    = 4
  31         sectionMemory   = 5
  32         sectionGlobal   = 6
  33         sectionExport   = 7
  34         sectionStart    = 8
  35         sectionElement  = 9
  36         sectionCode     = 10
  37         sectionData     = 11
  38 )
  39
  40 // funcValueOffset is the offset between the PC_F value of a function and the index of the function in WebAssembly
  41 const funcValueOffset = 0x1000 // TODO(neelance): make function addresses play nice with heap addresses
  42
  43 func gentext(ctxt *ld.Link, ldr *loader.Loader) {
  44 }
  45
  46 type wasmFunc struct {
  47         Name string
  48         Type uint32
  49         Code []byte
  50 }
  51
  52 type wasmFuncType struct {
  53         Params  []byte
  54         Results []byte
  55 }
  56
  57 var wasmFuncTypes = map[string]*wasmFuncType{
  58         "_rt0_wasm_js":           {Params: []byte{}},                                         //
  59         "wasm_export_run":        {Params: []byte{I32, I32}},                                 // argc, argv
  60         "wasm_export_resume":     {Params: []byte{}},                                         //
  61         "wasm_export_getsp":      {Results: []byte{I32}},                                     // sp
  62         "wasm_pc_f_loop":         {Params: []byte{}},                                         //
  63         "runtime.wasmMove":       {Params: []byte{I32, I32, I32}},                            // dst, src, len
  64         "runtime.wasmZero":       {Params: []byte{I32, I32}},                                 // ptr, len
  65         "runtime.wasmDiv":        {Params: []byte{I64, I64}, Results: []byte{I64}},           // x, y -> x/y
  66         "runtime.wasmTruncS":     {Params: []byte{F64}, Results: []byte{I64}},                // x -> int(x)
  67         "runtime.wasmTruncU":     {Params: []byte{F64}, Results: []byte{I64}},                // x -> uint(x)
  68         "runtime.gcWriteBarrier": {Params: []byte{I64, I64}},                                 // ptr, val
  69         "cmpbody":                {Params: []byte{I64, I64, I64, I64}, Results: []byte{I64}}, // a, alen, b, blen -> -1/0/1
  70         "memeqbody":              {Params: []byte{I64, I64, I64}, Results: []byte{I64}},      // a, b, len -> 0/1
  71         "memcmp":                 {Params: []byte{I32, I32, I32}, Results: []byte{I32}},      // a, b, len -> <0/0/>0
  72         "memchr":                 {Params: []byte{I32, I32, I32}, Results: []byte{I32}},      // s, c, len -> index
  73 }
  74
  75 func assignAddress(ldr *loader.Loader, sect *sym.Section, n int, s loader.Sym, va uint64, isTramp bool) (*sym.Section, int, uint64) {
  76         // WebAssembly functions do not live in the same address space as the linear memory.
  77         // Instead, WebAssembly automatically assigns indices. Imported functions (section "import")
  78         // have indices 0 to n. They are followed by native functions (sections "function" and "code")
  79         // with indices n+1 and following.
  80         //
  81         // The following rules describe how wasm handles function indices and addresses:
  82         //   PC_F = funcValueOffset + WebAssembly function index (not including the imports)
  83         //   s.Value = PC = PC_F<<16 + PC_B
  84         //
  85         // The funcValueOffset is necessary to avoid conflicts with expectations
  86         // that the Go runtime has about function addresses.
  87         // The field "s.Value" corresponds to the concept of PC at runtime.
  88         // However, there is no PC register, only PC_F and PC_B. PC_F denotes the function,
  89         // PC_B the resume point inside of that function. The entry of the function has PC_B = 0.
  90         ldr.SetSymSect(s, sect)
  91         ldr.SetSymValue(s, int64(funcValueOffset+va/ld.MINFUNC)<<16) // va starts at zero
  92         va += uint64(ld.MINFUNC)
  93         return sect, n, va
  94 }
  95
  96 type wasmDataSect struct {
  97         sect *sym.Section
  98         data []byte
  99 }
 100
 101 var dataSects []wasmDataSect
 102
 103 func asmb(ctxt *ld.Link, ldr *loader.Loader) {
 104         sections := []*sym.Section{
 105                 ldr.SymSect(ldr.Lookup("runtime.rodata", 0)),
 106                 ldr.SymSect(ldr.Lookup("runtime.typelink", 0)),
 107                 ldr.SymSect(ldr.Lookup("runtime.itablink", 0)),
 108                 ldr.SymSect(ldr.Lookup("runtime.symtab", 0)),
 109                 ldr.SymSect(ldr.Lookup("runtime.pclntab", 0)),
 110                 ldr.SymSect(ldr.Lookup("runtime.noptrdata", 0)),
 111                 ldr.SymSect(ldr.Lookup("runtime.data", 0)),
 112         }
 113
 114         dataSects = make([]wasmDataSect, len(sections))
 115         for i, sect := range sections {
 116                 data := ld.DatblkBytes(ctxt, int64(sect.Vaddr), int64(sect.Length))
 117                 dataSects[i] = wasmDataSect{sect, data}
 118         }
 119 }
 120
 121 // asmb writes the final WebAssembly module binary.
 122 // Spec: https://webassembly.github.io/spec/core/binary/modules.html
 123 func asmb2(ctxt *ld.Link, ldr *loader.Loader) {
 124         types := []*wasmFuncType{
 125                 // For normal Go functions, the single parameter is PC_B,
 126                 // the return value is
 127                 // 0 if the function returned normally or
 128                 // 1 if the stack needs to be unwound.
 129                 {Params: []byte{I32}, Results: []byte{I32}},
 130         }
 131
 132         // collect host imports (functions that get imported from the WebAssembly host, usually JavaScript)
 133         hostImports := []*wasmFunc{
 134                 {
 135                         Name: "debug",
 136                         Type: lookupType(&wasmFuncType{Params: []byte{I32}}, &types),
 137                 },
 138         }
 139         hostImportMap := make(map[loader.Sym]int64)
 140         for _, fn := range ctxt.Textp {
 141                 relocs := ldr.Relocs(fn)
 142                 for ri := 0; ri < relocs.Count(); ri++ {
 143                         r := relocs.At(ri)
 144                         if r.Type() == objabi.R_WASMIMPORT {
 145                                 hostImportMap[r.Sym()] = int64(len(hostImports))
 146                                 hostImports = append(hostImports, &wasmFunc{
 147                                         Name: ldr.SymName(r.Sym()),
 148                                         Type: lookupType(&wasmFuncType{Params: []byte{I32}}, &types),
 149                                 })
 150                         }
 151                 }
 152         }
 153
 154         // collect functions with WebAssembly body
 155         var buildid []byte
 156         fns := make([]*wasmFunc, len(ctxt.Textp))
 157         for i, fn := range ctxt.Textp {
 158                 wfn := new(bytes.Buffer)
 159                 if ldr.SymName(fn) == "go.buildid" {
 160                         writeUleb128(wfn, 0) // number of sets of locals
 161                         writeI32Const(wfn, 0)
 162                         wfn.WriteByte(0x0b) // end
 163                         buildid = ldr.Data(fn)
 164                 } else {
 165                         // Relocations have variable length, handle them here.
 166                         relocs := ldr.Relocs(fn)
 167                         P := ldr.Data(fn)
 168                         off := int32(0)
 169                         for ri := 0; ri < relocs.Count(); ri++ {
 170                                 r := relocs.At(ri)
 171                                 if r.Siz() == 0 {
 172                                         continue // skip marker relocations
 173                                 }
 174                                 wfn.Write(P[off:r.Off()])
 175                                 off = r.Off()
 176                                 rs := r.Sym()
 177                                 switch r.Type() {
 178                                 case objabi.R_ADDR:
 179                                         writeSleb128(wfn, ldr.SymValue(rs)+r.Add())
 180                                 case objabi.R_CALL:
 181                                         writeSleb128(wfn, int64(len(hostImports))+ldr.SymValue(rs)>>16-funcValueOffset)
 182                                 case objabi.R_WASMIMPORT:
 183                                         writeSleb128(wfn, hostImportMap[rs])
 184                                 default:
 185                                         ldr.Errorf(fn, "bad reloc type %d (%s)", r.Type(), sym.RelocName(ctxt.Arch, r.Type()))
 186                                         continue
 187                                 }
 188                         }
 189                         wfn.Write(P[off:])
 190                 }
 191
 192                 typ := uint32(0)
 193                 if sig, ok := wasmFuncTypes[ldr.SymName(fn)]; ok {
 194                         typ = lookupType(sig, &types)
 195                 }
 196
 197                 name := nameRegexp.ReplaceAllString(ldr.SymName(fn), "_")
 198                 fns[i] = &wasmFunc{Name: name, Type: typ, Code: wfn.Bytes()}
 199         }
 200
 201         ctxt.Out.Write([]byte{0x00, 0x61, 0x73, 0x6d}) // magic
 202         ctxt.Out.Write([]byte{0x01, 0x00, 0x00, 0x00}) // version
 203
 204         // Add any buildid early in the binary:
 205         if len(buildid) != 0 {
 206                 writeBuildID(ctxt, buildid)
 207         }
 208
 209         writeTypeSec(ctxt, types)
 210         writeImportSec(ctxt, hostImports)
 211         writeFunctionSec(ctxt, fns)
 212         writeTableSec(ctxt, fns)
 213         writeMemorySec(ctxt, ldr)
 214         writeGlobalSec(ctxt)
 215         writeExportSec(ctxt, ldr, len(hostImports))
 216         writeElementSec(ctxt, uint64(len(hostImports)), uint64(len(fns)))
 217         writeCodeSec(ctxt, fns)
 218         writeDataSec(ctxt)
 219         writeProducerSec(ctxt)
 220         if !*ld.FlagS {
 221                 writeNameSec(ctxt, len(hostImports), fns)
 222         }
 223 }
 224
 225 func lookupType(sig *wasmFuncType, types *[]*wasmFuncType) uint32 {
 226         for i, t := range *types {
 227                 if bytes.Equal(sig.Params, t.Params) && bytes.Equal(sig.Results, t.Results) {
 228                         return uint32(i)
 229                 }
 230         }
 231         *types = append(*types, sig)
 232         return uint32(len(*types) - 1)
 233 }
 234
 235 func writeSecHeader(ctxt *ld.Link, id uint8) int64 {
 236         ctxt.Out.WriteByte(id)
 237         sizeOffset := ctxt.Out.Offset()
 238         ctxt.Out.Write(make([]byte, 5)) // placeholder for length
 239         return sizeOffset
 240 }
 241
 242 func writeSecSize(ctxt *ld.Link, sizeOffset int64) {
 243         endOffset := ctxt.Out.Offset()
 244         ctxt.Out.SeekSet(sizeOffset)
 245         writeUleb128FixedLength(ctxt.Out, uint64(endOffset-sizeOffset-5), 5)
 246         ctxt.Out.SeekSet(endOffset)
 247 }
 248
 249 func writeBuildID(ctxt *ld.Link, buildid []byte) {
 250         sizeOffset := writeSecHeader(ctxt, sectionCustom)
 251         writeName(ctxt.Out, "go.buildid")
 252         ctxt.Out.Write(buildid)
 253         writeSecSize(ctxt, sizeOffset)
 254 }
 255
 256 // writeTypeSec writes the section that declares all function types
 257 // so they can be referenced by index.
 258 func writeTypeSec(ctxt *ld.Link, types []*wasmFuncType) {
 259         sizeOffset := writeSecHeader(ctxt, sectionType)
 260
 261         writeUleb128(ctxt.Out, uint64(len(types)))
 262
 263         for _, t := range types {
 264                 ctxt.Out.WriteByte(0x60) // functype
 265                 writeUleb128(ctxt.Out, uint64(len(t.Params)))
 266                 for _, v := range t.Params {
 267                         ctxt.Out.WriteByte(byte(v))
 268                 }
 269                 writeUleb128(ctxt.Out, uint64(len(t.Results)))
 270                 for _, v := range t.Results {
 271                         ctxt.Out.WriteByte(byte(v))
 272                 }
 273         }
 274
 275         writeSecSize(ctxt, sizeOffset)
 276 }
 277
 278 // writeImportSec writes the section that lists the functions that get
 279 // imported from the WebAssembly host, usually JavaScript.
 280 func writeImportSec(ctxt *ld.Link, hostImports []*wasmFunc) {
 281         sizeOffset := writeSecHeader(ctxt, sectionImport)
 282
 283         writeUleb128(ctxt.Out, uint64(len(hostImports))) // number of imports
 284         for _, fn := range hostImports {
 285                 writeName(ctxt.Out, "go") // provided by the import object in wasm_exec.js
 286                 writeName(ctxt.Out, fn.Name)
 287                 ctxt.Out.WriteByte(0x00) // func import
 288                 writeUleb128(ctxt.Out, uint64(fn.Type))
 289         }
 290
 291         writeSecSize(ctxt, sizeOffset)
 292 }
 293
 294 // writeFunctionSec writes the section that declares the types of functions.
 295 // The bodies of these functions will later be provided in the "code" section.
 296 func writeFunctionSec(ctxt *ld.Link, fns []*wasmFunc) {
 297         sizeOffset := writeSecHeader(ctxt, sectionFunction)
 298
 299         writeUleb128(ctxt.Out, uint64(len(fns)))
 300         for _, fn := range fns {
 301                 writeUleb128(ctxt.Out, uint64(fn.Type))
 302         }
 303
 304         writeSecSize(ctxt, sizeOffset)
 305 }
 306
 307 // writeTableSec writes the section that declares tables. Currently there is only a single table
 308 // that is used by the CallIndirect operation to dynamically call any function.
 309 // The contents of the table get initialized by the "element" section.
 310 func writeTableSec(ctxt *ld.Link, fns []*wasmFunc) {
 311         sizeOffset := writeSecHeader(ctxt, sectionTable)
 312
 313         numElements := uint64(funcValueOffset + len(fns))
 314         writeUleb128(ctxt.Out, 1)           // number of tables
 315         ctxt.Out.WriteByte(0x70)            // type: anyfunc
 316         ctxt.Out.WriteByte(0x00)            // no max
 317         writeUleb128(ctxt.Out, numElements) // min
 318
 319         writeSecSize(ctxt, sizeOffset)
 320 }
 321
 322 // writeMemorySec writes the section that declares linear memories. Currently one linear memory is being used.
 323 // Linear memory always starts at address zero. More memory can be requested with the GrowMemory instruction.
 324 func writeMemorySec(ctxt *ld.Link, ldr *loader.Loader) {
 325         sizeOffset := writeSecHeader(ctxt, sectionMemory)
 326
 327         dataSection := ldr.SymSect(ldr.Lookup("runtime.data", 0))
 328         dataEnd := dataSection.Vaddr + dataSection.Length
 329         var initialSize = dataEnd + 16<<20 // 16MB, enough for runtime init without growing
 330
 331         const wasmPageSize = 64 << 10 // 64KB
 332
 333         writeUleb128(ctxt.Out, 1)                        // number of memories
 334         ctxt.Out.WriteByte(0x00)                         // no maximum memory size
 335         writeUleb128(ctxt.Out, initialSize/wasmPageSize) // minimum (initial) memory size
 336
 337         writeSecSize(ctxt, sizeOffset)
 338 }
 339
 340 // writeGlobalSec writes the section that declares global variables.
 341 func writeGlobalSec(ctxt *ld.Link) {
 342         sizeOffset := writeSecHeader(ctxt, sectionGlobal)
 343
 344         globalRegs := []byte{
 345                 I32, // 0: SP
 346                 I64, // 1: CTXT
 347                 I64, // 2: g
 348                 I64, // 3: RET0
 349                 I64, // 4: RET1
 350                 I64, // 5: RET2
 351                 I64, // 6: RET3
 352                 I32, // 7: PAUSE
 353         }
 354
 355         writeUleb128(ctxt.Out, uint64(len(globalRegs))) // number of globals
 356
 357         for _, typ := range globalRegs {
 358                 ctxt.Out.WriteByte(typ)
 359                 ctxt.Out.WriteByte(0x01) // var
 360                 switch typ {
 361                 case I32:
 362                         writeI32Const(ctxt.Out, 0)
 363                 case I64:
 364                         writeI64Const(ctxt.Out, 0)
 365                 }
 366                 ctxt.Out.WriteByte(0x0b) // end
 367         }
 368
 369         writeSecSize(ctxt, sizeOffset)
 370 }
 371
 372 // writeExportSec writes the section that declares exports.
 373 // Exports can be accessed by the WebAssembly host, usually JavaScript.
 374 // The wasm_export_* functions and the linear memory get exported.
 375 func writeExportSec(ctxt *ld.Link, ldr *loader.Loader, lenHostImports int) {
 376         sizeOffset := writeSecHeader(ctxt, sectionExport)
 377
 378         writeUleb128(ctxt.Out, 4) // number of exports
 379
 380         for _, name := range []string{"run", "resume", "getsp"} {
 381                 s := ldr.Lookup("wasm_export_"+name, 0)
 382                 idx := uint32(lenHostImports) + uint32(ldr.SymValue(s)>>16) - funcValueOffset
 383                 writeName(ctxt.Out, name)           // inst.exports.run/resume/getsp in wasm_exec.js
 384                 ctxt.Out.WriteByte(0x00)            // func export
 385                 writeUleb128(ctxt.Out, uint64(idx)) // funcidx
 386         }
 387
 388         writeName(ctxt.Out, "mem") // inst.exports.mem in wasm_exec.js
 389         ctxt.Out.WriteByte(0x02)   // mem export
 390         writeUleb128(ctxt.Out, 0)  // memidx
 391
 392         writeSecSize(ctxt, sizeOffset)
 393 }
 394
 395 // writeElementSec writes the section that initializes the tables declared by the "table" section.
 396 // The table for CallIndirect gets initialized in a very simple way so that each table index (PC_F value)
 397 // maps linearly to the function index (numImports + PC_F).
 398 func writeElementSec(ctxt *ld.Link, numImports, numFns uint64) {
 399         sizeOffset := writeSecHeader(ctxt, sectionElement)
 400
 401         writeUleb128(ctxt.Out, 1) // number of element segments
 402
 403         writeUleb128(ctxt.Out, 0) // tableidx
 404         writeI32Const(ctxt.Out, funcValueOffset)
 405         ctxt.Out.WriteByte(0x0b) // end
 406
 407         writeUleb128(ctxt.Out, numFns) // number of entries
 408         for i := uint64(0); i < numFns; i++ {
 409                 writeUleb128(ctxt.Out, numImports+i)
 410         }
 411
 412         writeSecSize(ctxt, sizeOffset)
 413 }
 414
 415 // writeElementSec writes the section that provides the function bodies for the functions
 416 // declared by the "func" section.
 417 func writeCodeSec(ctxt *ld.Link, fns []*wasmFunc) {
 418         sizeOffset := writeSecHeader(ctxt, sectionCode)
 419
 420         writeUleb128(ctxt.Out, uint64(len(fns))) // number of code entries
 421         for _, fn := range fns {
 422                 writeUleb128(ctxt.Out, uint64(len(fn.Code)))
 423                 ctxt.Out.Write(fn.Code)
 424         }
 425
 426         writeSecSize(ctxt, sizeOffset)
 427 }
 428
 429 // writeDataSec writes the section that provides data that will be used to initialize the linear memory.
 430 func writeDataSec(ctxt *ld.Link) {
 431         sizeOffset := writeSecHeader(ctxt, sectionData)
 432
 433         type dataSegment struct {
 434                 offset int32
 435                 data   []byte
 436         }
 437
 438         // Omit blocks of zeroes and instead emit data segments with offsets skipping the zeroes.
 439         // This reduces the size of the WebAssembly binary. We use 8 bytes as an estimate for the
 440         // overhead of adding a new segment (same as wasm-opt's memory-packing optimization uses).
 441         const segmentOverhead = 8
 442
 443         // Generate at most this many segments. A higher number of segments gets rejected by some WebAssembly runtimes.
 444         const maxNumSegments = 100000
 445
 446         var segments []*dataSegment
 447         for secIndex, ds := range dataSects {
 448                 data := ds.data
 449                 offset := int32(ds.sect.Vaddr)
 450
 451                 // skip leading zeroes
 452                 for len(data) > 0 && data[0] == 0 {
 453                         data = data[1:]
 454                         offset++
 455                 }
 456
 457                 for len(data) > 0 {
 458                         dataLen := int32(len(data))
 459                         var segmentEnd, zeroEnd int32
 460                         if len(segments)+(len(dataSects)-secIndex) == maxNumSegments {
 461                                 segmentEnd = dataLen
 462                                 zeroEnd = dataLen
 463                         } else {
 464                                 for {
 465                                         // look for beginning of zeroes
 466                                         for segmentEnd < dataLen && data[segmentEnd] != 0 {
 467                                                 segmentEnd++
 468                                         }
 469                                         // look for end of zeroes
 470                                         zeroEnd = segmentEnd
 471                                         for zeroEnd < dataLen && data[zeroEnd] == 0 {
 472                                                 zeroEnd++
 473                                         }
 474                                         // emit segment if omitting zeroes reduces the output size
 475                                         if zeroEnd-segmentEnd >= segmentOverhead || zeroEnd == dataLen {
 476                                                 break
 477                                         }
 478                                         segmentEnd = zeroEnd
 479                                 }
 480                         }
 481
 482                         segments = append(segments, &dataSegment{
 483                                 offset: offset,
 484                                 data:   data[:segmentEnd],
 485                         })
 486                         data = data[zeroEnd:]
 487                         offset += zeroEnd
 488                 }
 489         }
 490
 491         writeUleb128(ctxt.Out, uint64(len(segments))) // number of data entries
 492         for _, seg := range segments {
 493                 writeUleb128(ctxt.Out, 0) // memidx
 494                 writeI32Const(ctxt.Out, seg.offset)
 495                 ctxt.Out.WriteByte(0x0b) // end
 496                 writeUleb128(ctxt.Out, uint64(len(seg.data)))
 497                 ctxt.Out.Write(seg.data)
 498         }
 499
 500         writeSecSize(ctxt, sizeOffset)
 501 }
 502
 503 // writeProducerSec writes an optional section that reports the source language and compiler version.
 504 func writeProducerSec(ctxt *ld.Link) {
 505         sizeOffset := writeSecHeader(ctxt, sectionCustom)
 506         writeName(ctxt.Out, "producers")
 507
 508         writeUleb128(ctxt.Out, 2) // number of fields
 509
 510         writeName(ctxt.Out, "language")       // field name
 511         writeUleb128(ctxt.Out, 1)             // number of values
 512         writeName(ctxt.Out, "Go")             // value: name
 513         writeName(ctxt.Out, buildcfg.Version) // value: version
 514
 515         writeName(ctxt.Out, "processed-by")   // field name
 516         writeUleb128(ctxt.Out, 1)             // number of values
 517         writeName(ctxt.Out, "Go cmd/compile") // value: name
 518         writeName(ctxt.Out, buildcfg.Version) // value: version
 519
 520         writeSecSize(ctxt, sizeOffset)
 521 }
 522
 523 var nameRegexp = regexp.MustCompile(`[^\w\.]`)
 524
 525 // writeNameSec writes an optional section that assigns names to the functions declared by the "func" section.
 526 // The names are only used by WebAssembly stack traces, debuggers and decompilers.
 527 // TODO(neelance): add symbol table of DATA symbols
 528 func writeNameSec(ctxt *ld.Link, firstFnIndex int, fns []*wasmFunc) {
 529         sizeOffset := writeSecHeader(ctxt, sectionCustom)
 530         writeName(ctxt.Out, "name")
 531
 532         sizeOffset2 := writeSecHeader(ctxt, 0x01) // function names
 533         writeUleb128(ctxt.Out, uint64(len(fns)))
 534         for i, fn := range fns {
 535                 writeUleb128(ctxt.Out, uint64(firstFnIndex+i))
 536                 writeName(ctxt.Out, fn.Name)
 537         }
 538         writeSecSize(ctxt, sizeOffset2)
 539
 540         writeSecSize(ctxt, sizeOffset)
 541 }
 542
 543 type nameWriter interface {
 544         io.ByteWriter
 545         io.Writer
 546 }
 547
 548 func writeI32Const(w io.ByteWriter, v int32) {
 549         w.WriteByte(0x41) // i32.const
 550         writeSleb128(w, int64(v))
 551 }
 552
 553 func writeI64Const(w io.ByteWriter, v int64) {
 554         w.WriteByte(0x42) // i64.const
 555         writeSleb128(w, v)
 556 }
 557
 558 func writeName(w nameWriter, name string) {
 559         writeUleb128(w, uint64(len(name)))
 560         w.Write([]byte(name))
 561 }
 562
 563 func writeUleb128(w io.ByteWriter, v uint64) {
 564         if v < 128 {
 565                 w.WriteByte(uint8(v))
 566                 return
 567         }
 568         more := true
 569         for more {
 570                 c := uint8(v & 0x7f)
 571                 v >>= 7
 572                 more = v != 0
 573                 if more {
 574                         c |= 0x80
 575                 }
 576                 w.WriteByte(c)
 577         }
 578 }
 579
 580 func writeUleb128FixedLength(w io.ByteWriter, v uint64, length int) {
 581         for i := 0; i < length; i++ {
 582                 c := uint8(v & 0x7f)
 583                 v >>= 7
 584                 if i < length-1 {
 585                         c |= 0x80
 586                 }
 587                 w.WriteByte(c)
 588         }
 589         if v != 0 {
 590                 panic("writeUleb128FixedLength: length too small")
 591         }
 592 }
 593
 594 func writeSleb128(w io.ByteWriter, v int64) {
 595         more := true
 596         for more {
 597                 c := uint8(v & 0x7f)
 598                 s := uint8(v & 0x40)
 599                 v >>= 7
 600                 more = !((v == 0 && s == 0) || (v == -1 && s != 0))
 601                 if more {
 602                         c |= 0x80
 603                 }
 604                 w.WriteByte(c)
 605         }
 606 }