229 lines
8.6 KiB
Go
229 lines
8.6 KiB
Go
// Copyright (c) 2026 Petr Balvín <opensource@petrbalvin.org> (https://petrbalvin.org)
|
|
// SPDX-License-Identifier: BSD-3-Clause
|
|
|
|
package parser
|
|
|
|
import (
|
|
"slices"
|
|
"strings"
|
|
"testing"
|
|
|
|
"sourcedock.dev/petrbalvin/gasm-sdk/ast"
|
|
)
|
|
|
|
// parseTextHeader parses the one TEXT directive of src, raw (no expansion).
|
|
func parseTextHeader(t *testing.T, header string) *ast.Text {
|
|
t.Helper()
|
|
f, errs := Parse("t.s", header+"\n\tRET\n")
|
|
if len(errs) > 0 {
|
|
t.Fatalf("parse %q: %v", header, errs)
|
|
}
|
|
return f.Decls[0].(*ast.Text)
|
|
}
|
|
|
|
// parseTextHeaderExpanded parses the one TEXT directive of src on the
|
|
// assembly path, where the toolchain's rejections apply.
|
|
func parseTextHeaderExpanded(t *testing.T, header string) (*ast.Text, []error) {
|
|
t.Helper()
|
|
f, errs := ParseWithOptions("t.s", header+"\n\tRET\n", Options{Expand: true})
|
|
if len(f.Decls) != 1 {
|
|
t.Fatalf("parse %q: %d decls, want 1", header, len(f.Decls))
|
|
}
|
|
return f.Decls[0].(*ast.Text), errs
|
|
}
|
|
|
|
// TestTextFlagsExpression covers the flags operand as one expression: names
|
|
// joined by '|', the legacy numeric spellings, and the arithmetic forms the
|
|
// toolchain's evalInteger folds. Names written purely keep their written
|
|
// order and duplicates; an operand with literals in it expands to the
|
|
// canonical ascending name list.
|
|
func TestTextFlagsExpression(t *testing.T) {
|
|
for _, c := range []struct {
|
|
operand string
|
|
wantFlag []string
|
|
wantVal int64
|
|
}{
|
|
{"NOSPLIT", []string{"NOSPLIT"}, 4},
|
|
{"NOSPLIT|NOFRAME|DUPOK", []string{"NOSPLIT", "NOFRAME", "DUPOK"}, 518},
|
|
{"TOPFRAME|NOSPLIT", []string{"TOPFRAME", "NOSPLIT"}, 2052},
|
|
{"NOSPLIT|NOSPLIT", []string{"NOSPLIT", "NOSPLIT"}, 4},
|
|
{"4", []string{"NOSPLIT"}, 4},
|
|
{"512", []string{"NOFRAME"}, 512},
|
|
{"2|4", []string{"DUPOK", "NOSPLIT"}, 6},
|
|
{"(NOSPLIT|NOFRAME)", []string{"NOSPLIT", "NOFRAME"}, 516},
|
|
{"NOSPLIT|4", []string{"NOSPLIT"}, 4},
|
|
{"NOSPLIT&DUPOK", nil, 0},
|
|
// The immediate spelling is the toolchain's "expected integer
|
|
// constant" on the assembly path; the raw view reads nothing from
|
|
// it and stays quiet.
|
|
{"$NOSPLIT", nil, 0},
|
|
} {
|
|
txt := parseTextHeader(t, "TEXT \u00b7f(SB), "+c.operand+", $0")
|
|
if !slices.Equal(txt.Flags, c.wantFlag) {
|
|
t.Errorf("%s: flags = %v, want %v", c.operand, txt.Flags, c.wantFlag)
|
|
}
|
|
if txt.FlagVal != c.wantVal {
|
|
t.Errorf("%s: FlagVal = %d, want %d", c.operand, txt.FlagVal, c.wantVal)
|
|
}
|
|
if txt.Frame == nil || !txt.Frame.Imm.HasVal || txt.Frame.Imm.Val != 0 {
|
|
t.Errorf("%s: frame = %+v, want $0", c.operand, txt.Frame)
|
|
}
|
|
}
|
|
|
|
// No flags operand at all: the toolchain's zero.
|
|
txt := parseTextHeader(t, "TEXT \u00b7f(SB), $0")
|
|
if txt.Flags != nil || txt.FlagVal != 0 {
|
|
t.Errorf("no flags: flags = %v val = %d, want nil 0", txt.Flags, txt.FlagVal)
|
|
}
|
|
}
|
|
|
|
// TestTextFlagValues pins the flag table against the constants
|
|
// cmd/internal/obj/textflag.go defines and the toolchain's textflag.h
|
|
// ships; the assembler, linker and compiler must all agree on them.
|
|
func TestTextFlagValues(t *testing.T) {
|
|
for _, c := range []struct {
|
|
name string
|
|
val int64
|
|
}{
|
|
{"NOPROF", 1}, {"DUPOK", 2}, {"NOSPLIT", 4}, {"RODATA", 8},
|
|
{"NOPTR", 16}, {"WRAPPER", 32}, {"NEEDCTXT", 64}, {"TLSBSS", 256},
|
|
{"NOFRAME", 512}, {"REFLECTMETHOD", 1024}, {"TOPFRAME", 2048},
|
|
{"ABIWRAPPER", 4096},
|
|
} {
|
|
txt := parseTextHeader(t, "TEXT \u00b7f(SB), "+c.name+", $0")
|
|
if txt.FlagVal != c.val {
|
|
t.Errorf("%s = %d, want %d", c.name, txt.FlagVal, c.val)
|
|
}
|
|
if !slices.Equal(txt.Flags, []string{c.name}) {
|
|
t.Errorf("%s: flags = %v, want [%s]", c.name, txt.Flags, c.name)
|
|
}
|
|
}
|
|
}
|
|
|
|
// TestFlagsUnknownName covers the identifier the table does not know: the
|
|
// toolchain's assembler rejects the line ("unexpected TYPO evaluating
|
|
// expression") and so does the assembly path of this parser, while the
|
|
// tooling view stays tolerant, keeps the scanned names and carries no
|
|
// value the assembler could trust.
|
|
func TestFlagsUnknownName(t *testing.T) {
|
|
const header = "TEXT \u00b7f(SB), NOSPLIT|TYPO, $0"
|
|
|
|
txt := parseTextHeader(t, header)
|
|
if !slices.Equal(txt.Flags, []string{"NOSPLIT", "TYPO"}) {
|
|
t.Errorf("raw flags = %v, want the scanned names", txt.Flags)
|
|
}
|
|
if txt.FlagVal != 0 {
|
|
t.Errorf("raw FlagVal = %d, want 0", txt.FlagVal)
|
|
}
|
|
|
|
_, errs := parseTextHeaderExpanded(t, header)
|
|
if len(errs) != 1 {
|
|
t.Fatalf("assembly path: %d errors, want 1: %v", len(errs), errs)
|
|
}
|
|
perr, ok := errs[0].(Error)
|
|
if !ok {
|
|
t.Fatalf("error %v is not a parser.Error", errs[0])
|
|
}
|
|
if !strings.Contains(perr.Msg, "unexpected TYPO evaluating expression") {
|
|
t.Errorf("message = %q, want the toolchain's rejection", perr.Msg)
|
|
}
|
|
if perr.Pos.Line != 1 || perr.Pos.Column != 22 {
|
|
t.Errorf("position = %d:%d, want 1:22", perr.Pos.Line, perr.Pos.Column)
|
|
}
|
|
}
|
|
|
|
// TestFlagsLeftoverExpression covers the operand that never closes into
|
|
// one expression: the toolchain rejects it where the expression stops.
|
|
func TestFlagsLeftoverExpression(t *testing.T) {
|
|
_, errs := parseTextHeaderExpanded(t, "TEXT \u00b7f(SB), NOSPLIT TYPO, $0")
|
|
if len(errs) != 1 || !strings.Contains(errs[0].Error(), "unexpected TYPO evaluating expression") {
|
|
t.Fatalf("errors = %v, want the toolchain's rejection at TYPO", errs)
|
|
}
|
|
txt := parseTextHeader(t, "TEXT \u00b7f(SB), NOSPLIT TYPO, $0")
|
|
if txt.FlagVal != 0 {
|
|
t.Errorf("raw FlagVal = %d, want 0", txt.FlagVal)
|
|
}
|
|
}
|
|
|
|
// TestNoFrameDemandsZeroFrame covers the toolchain's frame check its arm64
|
|
// backend raises: NOFRAME reserves no frame, so a declared positive frame
|
|
// contradicts the flag. The zero and negative frames are the flag's own
|
|
// shapes (the arm64 BSD syscall-stub pattern writes $-8).
|
|
func TestNoFrameDemandsZeroFrame(t *testing.T) {
|
|
_, errs := parseTextHeaderExpanded(t, "TEXT \u00b7f(SB), NOSPLIT|NOFRAME, $8")
|
|
if len(errs) != 1 || !strings.Contains(errs[0].Error(),
|
|
"NOFRAME functions must have a frame size of 0, not 8") {
|
|
t.Fatalf("errors = %v, want the toolchain's frame check", errs)
|
|
}
|
|
for _, frame := range []string{"$0", "$-8", "$-0"} {
|
|
if _, errs := parseTextHeaderExpanded(t, "TEXT \u00b7f(SB), NOSPLIT|NOFRAME, "+frame); len(errs) != 0 {
|
|
t.Errorf("%s: errors = %v, want none", frame, errs)
|
|
}
|
|
}
|
|
// The tooling view leaves the case to the linter's advisory.
|
|
txt := parseTextHeader(t, "TEXT \u00b7f(SB), NOSPLIT|NOFRAME, $8")
|
|
if txt.Frame == nil {
|
|
t.Fatal("raw parse lost the frame")
|
|
}
|
|
}
|
|
|
|
// TestABIInternalRequiresNoSplit covers the toolchain's own TEXT check: an
|
|
// ABIInternal symbol must not need the stack the ABI wrapper would have to
|
|
// bridge, so the flag is mandatory.
|
|
func TestABIInternalRequiresNoSplit(t *testing.T) {
|
|
_, errs := parseTextHeaderExpanded(t, "TEXT \u00b7f<ABIInternal>(SB), $0")
|
|
if len(errs) != 1 || !strings.Contains(errs[0].Error(),
|
|
`TEXT "f": ABIInternal requires NOSPLIT`) {
|
|
t.Fatalf("errors = %v, want the toolchain's ABI check", errs)
|
|
}
|
|
if _, errs := parseTextHeaderExpanded(t, "TEXT \u00b7f<ABIInternal>(SB), NOSPLIT, $0"); len(errs) != 0 {
|
|
t.Errorf("NOSPLIT present: errors = %v, want none", errs)
|
|
}
|
|
// The numeric spelling of the flag satisfies the check the same way
|
|
// the toolchain's integer test does.
|
|
if _, errs := parseTextHeaderExpanded(t, "TEXT \u00b7f<ABIInternal>(SB), 4, $0"); len(errs) != 0 {
|
|
t.Errorf("numeric NOSPLIT: errors = %v, want none", errs)
|
|
}
|
|
}
|
|
|
|
// TestGloblFlagsOperand covers the GLOBL side: the atoms stay as written
|
|
// (the numeric combinations are what the link layer reads back) while the
|
|
// operand still folds to one value and validates on the assembly path.
|
|
func TestGloblFlagsOperand(t *testing.T) {
|
|
for _, c := range []struct {
|
|
operand string
|
|
wantFlag []string
|
|
wantVal int64
|
|
wantSize int64
|
|
}{
|
|
{"RODATA|NOPTR, $8", []string{"RODATA", "NOPTR"}, 24, 8},
|
|
{"10, $8", []string{"10"}, 10, 8},
|
|
{"8|2, $8", []string{"8", "2"}, 10, 8},
|
|
{"RODATA, $8", []string{"RODATA"}, 8, 8},
|
|
{"$8", nil, 0, 8},
|
|
} {
|
|
f, errs := Parse("t.s", "GLOBL \u00b7x(SB), "+c.operand+"\n")
|
|
if len(errs) > 0 {
|
|
t.Fatalf("parse %q: %v", c.operand, errs)
|
|
}
|
|
g := f.Decls[0].(*ast.Globl)
|
|
if !slices.Equal(g.Flags, c.wantFlag) {
|
|
t.Errorf("%s: flags = %v, want %v", c.operand, g.Flags, c.wantFlag)
|
|
}
|
|
if g.FlagVal != c.wantVal {
|
|
t.Errorf("%s: FlagVal = %d, want %d", c.operand, g.FlagVal, c.wantVal)
|
|
}
|
|
if c.wantSize != 0 && (g.Size == nil || !g.Size.Imm.HasVal || g.Size.Imm.Val != c.wantSize) {
|
|
t.Errorf("%s: size = %+v, want $%d", c.operand, g.Size, c.wantSize)
|
|
}
|
|
}
|
|
|
|
f, errs := ParseWithOptions("t.s", "GLOBL \u00b7x(SB), RODATA|TYPO, $8\n", Options{Expand: true})
|
|
if len(errs) != 1 || !strings.Contains(errs[0].Error(), "unexpected TYPO evaluating expression") {
|
|
t.Fatalf("errors = %v, want the toolchain's rejection", errs)
|
|
}
|
|
if f.Decls[0].(*ast.Globl).FlagVal != 0 {
|
|
t.Errorf("failed operand must carry no value")
|
|
}
|
|
}
|