Files
wuffs/cmd/wuffs-c/internal/cgen/builtin.go
T

540 lines
15 KiB
Go

// Copyright 2017 The Wuffs Authors.
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
// https://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.
package cgen
import (
"errors"
"fmt"
a "github.com/google/wuffs/lang/ast"
t "github.com/google/wuffs/lang/token"
)
var errNoSuchBuiltin = errors.New("cgen: internal error: no such built-in")
func (g *gen) writeBuiltinCall(b *buffer, n *a.Expr, rp replacementPolicy, depth uint32) error {
if n.Operator() != t.IDOpenParen {
return errNoSuchBuiltin
}
method := n.LHS().AsExpr()
recv := method.LHS().AsExpr()
recvTyp := recv.MType()
switch recvTyp.Decorator() {
case 0:
// No-op.
case t.IDNptr, t.IDPtr:
// TODO: don't hard-code initialize.
if method.Ident() != g.tm.ByName("initialize") {
return errNoSuchBuiltin
}
// TODO: don't hard-code a_dst.
b.printf("wuffs_base__image_config__initialize(a_dst")
for _, o := range n.Args() {
b.writeb(',')
if err := g.writeExpr(b, o.AsArg().Value(), rp, depth); err != nil {
return err
}
}
b.printf(")")
return nil
case t.IDSlice:
return g.writeBuiltinSlice(b, recv, method.Ident(), n.Args(), rp, depth)
case t.IDTable:
return g.writeBuiltinTable(b, recv, method.Ident(), n.Args(), rp, depth)
default:
return errNoSuchBuiltin
}
qid := recvTyp.QID()
if qid[0] != t.IDBase {
return errNoSuchBuiltin
}
if qid[1].IsNumType() {
return g.writeBuiltinNumType(b, recv, method.Ident(), n.Args(), rp, depth)
} else {
switch qid[1] {
case t.IDIOReader:
return g.writeBuiltinIOReader(b, recv, method.Ident(), n.Args(), rp, depth)
case t.IDIOWriter:
return g.writeBuiltinIOWriter(b, recv, method.Ident(), n.Args(), rp, depth)
}
}
return errNoSuchBuiltin
}
func (g *gen) writeBuiltinIO(b *buffer, recv *a.Expr, method t.ID, args []*a.Node, rp replacementPolicy, depth uint32) error {
switch method {
case t.IDAvailable:
p0, p1 := "", ""
// TODO: don't hard-code these.
switch recv.Str(g.tm) {
case "args.dst":
p0 = "io1_a_dst"
p1 = "iop_a_dst"
case "args.src":
p0 = "io1_a_src"
p1 = "iop_a_src"
case "w":
p0 = "io1_v_w"
p1 = "iop_v_w"
}
if p0 == "" {
return fmt.Errorf(`TODO: cgen a "foo.available" expression`)
}
b.printf("((uint64_t)(%s - %s))", p0, p1)
return nil
case t.IDSet:
typ := "reader"
if len(args) == 1 {
typ = "writer"
}
// TODO: don't hard-code v_w and u_w.
b.printf("wuffs_base__io_%s__set(&v_w, &u_w, &iop_v_w, &io1_v_w,", typ)
return g.writeArgs(b, args, rp, depth)
}
return errNoSuchBuiltin
}
func (g *gen) writeBuiltinIOReader(b *buffer, recv *a.Expr, method t.ID, args []*a.Node, rp replacementPolicy, depth uint32) error {
// TODO: don't hard-code the recv being a_src.
switch method {
case t.IDUndoByte:
b.writes("(iop_a_src--, wuffs_base__return_empty_struct())")
return nil
case t.IDCanUndoByte:
b.writes("(iop_a_src > io0_a_src)")
return nil
case t.IDSetLimit:
b.printf("wuffs_base__io_reader__set_limit(&%ssrc, iop_a_src,", aPrefix)
// TODO: update the iop variables?
return g.writeArgs(b, args, rp, depth)
case t.IDSetMark:
b.printf("wuffs_base__io_reader__set_mark(&%ssrc, iop_a_src)", aPrefix)
return nil
case t.IDSinceMark:
b.printf("((wuffs_base__slice_u8){ "+
".ptr = %ssrc.private_impl.mark, "+
".len = (size_t)(iop_a_src - %ssrc.private_impl.mark), })",
aPrefix, aPrefix)
return nil
case t.IDSkipFast:
// Generate a two part expression using the comma operator: "(pointer
// increment, return_empty_struct call)". The final part is a function
// call (to a static inline function) instead of a struct literal, to
// avoid a "expression result unused" compiler error.
b.writes("(iop_a_src += ")
if err := g.writeExpr(b, args[1].AsArg().Value(), rp, depth); err != nil {
return err
}
b.writes(", wuffs_base__return_empty_struct())")
return nil
}
if method >= peekMethodsBase {
if m := method - peekMethodsBase; m < t.ID(len(peekMethods)) {
if p := peekMethods[m]; p.n != 0 {
b.printf("wuffs_base__load_u%d%ce(iop_a_src)", p.n, p.endianness)
return nil
}
}
}
return g.writeBuiltinIO(b, recv, method, args, rp, depth)
}
func (g *gen) writeBuiltinIOWriter(b *buffer, recv *a.Expr, method t.ID, args []*a.Node, rp replacementPolicy, depth uint32) error {
// TODO: don't hard-code the recv being a_dst.
switch method {
case t.IDCopyNFromHistory, t.IDCopyNFromHistoryFast:
suffix := ""
if method == t.IDCopyNFromHistoryFast {
suffix = "_fast"
}
b.printf("wuffs_base__io_writer__copy_n_from_history%s("+
"&iop_a_dst, %sdst.private_impl.mark, io1_a_dst",
suffix, aPrefix)
for _, o := range args {
b.writeb(',')
if err := g.writeExpr(b, o.AsArg().Value(), rp, depth); err != nil {
return err
}
}
b.writeb(')')
return nil
case t.IDCopyNFromReader:
b.printf("wuffs_base__io_writer__copy_n_from_reader(&iop_a_dst, io1_a_dst,")
if err := g.writeExpr(b, args[0].AsArg().Value(), rp, depth); err != nil {
return err
}
// TODO: don't assume that the last argument is "args.src".
b.printf(", &iop_a_src, io1_a_src)")
return nil
case t.IDCopyFromSlice:
b.printf("wuffs_base__io_writer__copy_from_slice(&iop_a_dst, io1_a_dst,")
return g.writeArgs(b, args, rp, depth)
case t.IDCopyNFromSlice:
b.printf("wuffs_base__io_writer__copy_n_from_slice(&iop_a_dst, io1_a_dst,")
return g.writeArgs(b, args, rp, depth)
case t.IDSetMark:
// TODO: is a private_impl.mark the right representation? What
// if the function is passed a (ptr io_writer) instead of a
// (io_writer)? Do we still want to have that mark live outside of
// the function scope?
b.printf("wuffs_base__io_writer__set_mark(&%sdst, iop_a_dst)", aPrefix)
return nil
case t.IDSinceMark:
b.printf("((wuffs_base__slice_u8){ "+
".ptr = %sdst.private_impl.mark, "+
".len = (size_t)(iop_a_dst - %sdst.private_impl.mark), })",
aPrefix, aPrefix)
return nil
}
if method >= writeFastMethodsBase {
if m := method - writeFastMethodsBase; m < t.ID(len(writeFastMethods)) {
if p := writeFastMethods[m]; p.n != 0 {
// Generate a three part expression using the comma operator:
// "(store, pointer increment, return_empty_struct call)". The
// final part is a function call (to a static inline function)
// instead of a struct literal, to avoid a "expression result
// unused" compiler error.
b.printf("(wuffs_base__store_u%d%ce(iop_a_dst,", p.n, p.endianness)
if err := g.writeExpr(b, args[0].AsArg().Value(), rp, depth); err != nil {
return err
}
b.printf("), iop_a_dst += %d, wuffs_base__return_empty_struct())", p.n/8)
return nil
}
}
}
return g.writeBuiltinIO(b, recv, method, args, rp, depth)
}
func (g *gen) writeBuiltinNumType(b *buffer, recv *a.Expr, method t.ID, args []*a.Node, rp replacementPolicy, depth uint32) error {
switch method {
case t.IDLowBits:
// "recv.low_bits(n:etc)" in C is "((recv) & ((1 << (n)) - 1))".
b.writes("((")
if err := g.writeExpr(b, recv, rp, depth); err != nil {
return err
}
b.writes(") & ((1 << (")
if err := g.writeExpr(b, args[0].AsArg().Value(), rp, depth); err != nil {
return err
}
b.writes(")) - 1))")
return nil
case t.IDHighBits:
// "recv.high_bits(n:etc)" in C is "((recv) >> (8*sizeof(recv) - (n)))".
b.writes("((")
if err := g.writeExpr(b, recv, rp, depth); err != nil {
return err
}
b.writes(") >> (")
if sz, err := g.sizeof(recv.MType()); err != nil {
return err
} else {
b.printf("%d", 8*sz)
}
b.writes(" - (")
if err := g.writeExpr(b, args[0].AsArg().Value(), rp, depth); err != nil {
return err
}
b.writes(")))")
return nil
case t.IDMax:
b.writes("wuffs_base__u")
if sz, err := g.sizeof(recv.MType()); err != nil {
return err
} else {
b.printf("%d", 8*sz)
}
b.writes("__max(")
if err := g.writeExpr(b, recv, rp, depth); err != nil {
return err
}
b.writes(",")
if err := g.writeExpr(b, args[0].AsArg().Value(), rp, depth); err != nil {
return err
}
b.writes(")")
return nil
case t.IDMin:
b.writes("wuffs_base__u")
if sz, err := g.sizeof(recv.MType()); err != nil {
return err
} else {
b.printf("%d", 8*sz)
}
b.writes("__min(")
if err := g.writeExpr(b, recv, rp, depth); err != nil {
return err
}
b.writes(",")
if err := g.writeExpr(b, args[0].AsArg().Value(), rp, depth); err != nil {
return err
}
b.writes(")")
return nil
}
return errNoSuchBuiltin
}
func (g *gen) writeBuiltinSlice(b *buffer, recv *a.Expr, method t.ID, args []*a.Node, rp replacementPolicy, depth uint32) error {
switch method {
case t.IDCopyFromSlice:
// TODO: don't assume that the slice is a slice of base.u8.
b.writes("wuffs_base__slice_u8__copy_from_slice(")
if err := g.writeExpr(b, recv, rp, depth); err != nil {
return err
}
b.writeb(',')
return g.writeArgs(b, args, rp, depth)
case t.IDLength:
b.writes("((uint64_t)(")
if err := g.writeExpr(b, recv, rp, depth); err != nil {
return err
}
b.writes(".len))")
return nil
case t.IDSuffix:
// TODO: don't assume that the slice is a slice of base.u8.
b.writes("wuffs_base__slice_u8__suffix(")
if err := g.writeExpr(b, recv, rp, depth); err != nil {
return err
}
b.writeb(',')
return g.writeArgs(b, args, rp, depth)
}
return errNoSuchBuiltin
}
func (g *gen) writeBuiltinTable(b *buffer, recv *a.Expr, method t.ID, args []*a.Node, rp replacementPolicy, depth uint32) error {
field := ""
switch method {
case t.IDHeight:
field = "height"
case t.IDStride:
field = "stride"
case t.IDWidth:
field = "width"
case t.IDRow:
// TODO: don't assume that the table is a table of base.u8.
b.writes("wuffs_base__table_u8__row(")
if err := g.writeExpr(b, recv, rp, depth); err != nil {
return err
}
b.writeb(',')
return g.writeArgs(b, args, rp, depth)
}
if field != "" {
b.writes("((uint64_t)(")
if err := g.writeExpr(b, recv, rp, depth); err != nil {
return err
}
b.printf(".%s))", field)
return nil
}
return errNoSuchBuiltin
}
func (g *gen) writeArgs(b *buffer, args []*a.Node, rp replacementPolicy, depth uint32) error {
for i, o := range args {
if i > 0 {
b.writeb(',')
}
if err := g.writeExpr(b, o.AsArg().Value(), rp, depth); err != nil {
return err
}
}
b.writes(")")
return nil
}
func (g *gen) writeBuiltinCallSuspendibles(b *buffer, n *a.Expr, depth uint32) error {
// TODO: also handle (or reject??) t.IDTry.
if n.Operator() != t.IDOpenParen {
return errNoSuchBuiltin
}
method := n.LHS().AsExpr()
recv := method.LHS().AsExpr()
recvTyp := recv.MType()
if !recvTyp.IsIOType() {
return errNoSuchBuiltin
}
if recvTyp.QID()[1] == t.IDIOReader {
switch method.Ident() {
case t.IDReadU8:
if g.currFunk.tempW > maxTemp {
return fmt.Errorf("too many temporary variables required")
}
temp := g.currFunk.tempW
g.currFunk.tempW++
b.printf("if (WUFFS_BASE__UNLIKELY(iop_a_src == io1_a_src)) {" +
"status = wuffs_base__suspension__short_read; goto suspend; }")
// TODO: watch for passing an array type to writeCTypeName? In C, an
// array type can decay into a pointer.
if err := g.writeCTypeName(b, n.MType(), tPrefix, fmt.Sprint(temp)); err != nil {
return err
}
b.printf(" = *iop_a_src++;\n")
return nil
case t.IDReadU16BE:
return g.writeReadUXX(b, n, "a_src", 16, "be")
case t.IDReadU16LE:
return g.writeReadUXX(b, n, "a_src", 16, "le")
case t.IDReadU24BE:
return g.writeReadUXX(b, n, "a_src", 24, "be")
case t.IDReadU24LE:
return g.writeReadUXX(b, n, "a_src", 24, "le")
case t.IDReadU32BE:
return g.writeReadUXX(b, n, "a_src", 32, "be")
case t.IDReadU32LE:
return g.writeReadUXX(b, n, "a_src", 32, "le")
case t.IDReadU40BE:
return g.writeReadUXX(b, n, "a_src", 40, "be")
case t.IDReadU40LE:
return g.writeReadUXX(b, n, "a_src", 40, "le")
case t.IDReadU48BE:
return g.writeReadUXX(b, n, "a_src", 48, "be")
case t.IDReadU48LE:
return g.writeReadUXX(b, n, "a_src", 48, "le")
case t.IDReadU56BE:
return g.writeReadUXX(b, n, "a_src", 56, "be")
case t.IDReadU56LE:
return g.writeReadUXX(b, n, "a_src", 56, "le")
case t.IDReadU64BE:
return g.writeReadUXX(b, n, "a_src", 64, "be")
case t.IDReadU64LE:
return g.writeReadUXX(b, n, "a_src", 64, "le")
case t.IDSkip:
g.currFunk.usesScratch = true
// TODO: don't hard-code [0], and allow recursive coroutines.
scratchName := fmt.Sprintf("self->private_impl.%s%s[0].scratch",
cPrefix, g.currFunk.astFunc.FuncName().Str(g.tm))
b.printf("%s = ", scratchName)
x := n.Args()[0].AsArg().Value()
if err := g.writeExpr(b, x, replaceCallSuspendibles, depth); err != nil {
return err
}
b.writes(";\n")
// TODO: the CSP prior to this is probably unnecessary.
if err := g.writeCoroSuspPoint(b, false); err != nil {
return err
}
b.printf("if (%s > ((uint64_t)(io1_a_src - iop_a_src))) {\n", scratchName)
b.printf("%s -= io1_a_src - iop_a_src;\n", scratchName)
b.printf("iop_a_src = io1_a_src;\n")
b.writes("status = wuffs_base__suspension__short_read; goto suspend; }\n")
b.printf("iop_a_src += %s;\n", scratchName)
return nil
}
} else {
switch method.Ident() {
case t.IDWriteU8:
b.writes("if (iop_a_dst == io1_a_dst) {\n" +
"status = wuffs_base__suspension__short_write; goto suspend; }\n" +
"*iop_a_dst++ = ")
x := n.Args()[0].AsArg().Value()
if err := g.writeExpr(b, x, replaceCallSuspendibles, depth); err != nil {
return err
}
b.writes(";\n")
return nil
}
}
return errNoSuchBuiltin
}
const peekMethodsBase = t.IDPeekU8
var peekMethods = [...]struct {
n uint8
endianness uint8
}{
t.IDPeekU8 - peekMethodsBase: {8, 'b'},
t.IDPeekU16BE - peekMethodsBase: {16, 'b'},
t.IDPeekU16LE - peekMethodsBase: {16, 'l'},
t.IDPeekU24BE - peekMethodsBase: {24, 'b'},
t.IDPeekU24LE - peekMethodsBase: {24, 'l'},
t.IDPeekU32BE - peekMethodsBase: {32, 'b'},
t.IDPeekU32LE - peekMethodsBase: {32, 'l'},
t.IDPeekU40BE - peekMethodsBase: {40, 'b'},
t.IDPeekU40LE - peekMethodsBase: {40, 'l'},
t.IDPeekU48BE - peekMethodsBase: {48, 'b'},
t.IDPeekU48LE - peekMethodsBase: {48, 'l'},
t.IDPeekU56BE - peekMethodsBase: {56, 'b'},
t.IDPeekU56LE - peekMethodsBase: {56, 'l'},
t.IDPeekU64BE - peekMethodsBase: {64, 'b'},
t.IDPeekU64LE - peekMethodsBase: {64, 'l'},
}
const writeFastMethodsBase = t.IDWriteFastU8
var writeFastMethods = [...]struct {
n uint8
endianness uint8
}{
t.IDWriteFastU8 - writeFastMethodsBase: {8, 'b'},
t.IDWriteFastU16BE - writeFastMethodsBase: {16, 'b'},
t.IDWriteFastU16LE - writeFastMethodsBase: {16, 'l'},
t.IDWriteFastU24BE - writeFastMethodsBase: {24, 'b'},
t.IDWriteFastU24LE - writeFastMethodsBase: {24, 'l'},
t.IDWriteFastU32BE - writeFastMethodsBase: {32, 'b'},
t.IDWriteFastU32LE - writeFastMethodsBase: {32, 'l'},
t.IDWriteFastU40BE - writeFastMethodsBase: {40, 'b'},
t.IDWriteFastU40LE - writeFastMethodsBase: {40, 'l'},
t.IDWriteFastU48BE - writeFastMethodsBase: {48, 'b'},
t.IDWriteFastU48LE - writeFastMethodsBase: {48, 'l'},
t.IDWriteFastU56BE - writeFastMethodsBase: {56, 'b'},
t.IDWriteFastU56LE - writeFastMethodsBase: {56, 'l'},
t.IDWriteFastU64BE - writeFastMethodsBase: {64, 'b'},
t.IDWriteFastU64LE - writeFastMethodsBase: {64, 'l'},
}