cmd/irdump: formatted disassembly

Tests requiring internet access or unreasonable dependencies are removed.

Signed-off-by: Ophestra <cat@gensokyo.uk>

cmd/irdump/main.go

@@ -0,0 +1,76 @@
+package main
+
+import (
+	"errors"
+	"log"
+	"os"
+
+	"hakurei.app/command"
+	"hakurei.app/internal/pkg"
+)
+
+func main() {
+	log.SetFlags(0)
+	log.SetPrefix("irdump: ")
+
+	var (
+		flagOutput string
+		flagReal   bool
+		flagHeader bool
+		flagForce  bool
+		flagRaw    bool
+	)
+	c := command.New(os.Stderr, log.Printf, "irdump", func(args []string) (err error) {
+		var input *os.File
+		if len(args) != 1 {
+			return errors.New("irdump requires 1 argument")
+		}
+		if input, err = os.Open(args[0]); err != nil {
+			return
+		}
+		defer input.Close()
+
+		var output *os.File
+		if flagOutput == "" {
+			output = os.Stdout
+		} else {
+			defer output.Close()
+			if output, err = os.Create(flagOutput); err != nil {
+				return
+			}
+		}
+
+		var out string
+		if out, err = pkg.Disassemble(input, flagReal, flagHeader, flagForce, flagRaw); err != nil {
+			return
+		}
+		if _, err = output.WriteString(out); err != nil {
+			return
+		}
+		return
+	}).Flag(
+		&flagOutput,
+		"o", command.StringFlag(""),
+		"Output file for asm (leave empty for stdout)",
+	).Flag(
+		&flagReal,
+		"r", command.BoolFlag(false),
+		"skip label generation; idents print real value",
+	).Flag(
+		&flagHeader,
+		"H", command.BoolFlag(false),
+		"display artifact headers",
+	).Flag(
+		&flagForce,
+		"f", command.BoolFlag(false),
+		"force display (skip validations)",
+	).Flag(
+		&flagRaw,
+		"R", command.BoolFlag(false),
+		"don't format output",
+	)
+
+	c.MustParse(os.Args[1:], func(err error) {
+		log.Fatal(err)
+	})
+}

internal/pkg/asm.go

@@ -0,0 +1,216 @@
+package pkg
+
+import (
+	"encoding/binary"
+	"fmt"
+	"io"
+	"strconv"
+	"strings"
+)
+
+type asmOutLine struct {
+	pos       int
+	word      int
+	kindData  int64
+	valueData []byte
+	indent    int
+	kind      string
+	value     string
+}
+
+var spacingLine = asmOutLine{
+	pos:       -1,
+	kindData:  -1,
+	valueData: nil,
+	indent:    0,
+	kind:      "",
+	value:     "",
+}
+
+func Disassemble(r io.Reader, real bool, showHeader bool, force bool, raw bool) (s string, err error) {
+	var lines []asmOutLine
+	sb := new(strings.Builder)
+	header := true
+	pos := new(int)
+
+	for err == nil {
+		if header {
+			var kind uint64
+			var size uint64
+			var bsize []byte
+			p := *pos
+			if _, kind, err = nextUint64(r, pos); err != nil {
+				break
+			}
+			if bsize, size, err = nextUint64(r, pos); err != nil {
+				break
+			}
+			if showHeader {
+				lines = append(lines, asmOutLine{p, 8, int64(kind), bsize, 0, "head  " + intToKind(kind), ""})
+			}
+			for i := 0; uint64(i) < size; i++ {
+				var did Checksum
+				var dkind uint64
+				p := *pos
+				if _, dkind, err = nextUint64(r, pos); err != nil {
+					break
+				}
+				if _, did, err = nextIdent(r, pos); err != nil {
+					break
+				}
+				if showHeader {
+					lines = append(lines, asmOutLine{p, 8, int64(dkind), nil, 1, intToKind(dkind), Encode(did)})
+				}
+			}
+			header = false
+		}
+		var k uint32
+		p := *pos
+		if _, k, err = nextUint32(r, pos); err != nil {
+			break
+		}
+		kind := IRValueKind(k)
+		switch kind {
+		case IRKindEnd:
+			var a uint32
+			var ba []byte
+			if ba, a, err = nextUint32(r, pos); err != nil {
+				break
+			}
+			if a&1 != 0 {
+				var sum Checksum
+				if _, sum, err = nextIdent(r, pos); err != nil {
+					break
+				}
+				lines = append(lines, asmOutLine{p, 4, int64(kind), ba, 1, "end ", Encode(sum)})
+			} else {
+				lines = append(lines, asmOutLine{p, 4, int64(kind), []byte{0, 0, 0, 0}, 1, "end ", ""})
+			}
+			lines = append(lines, spacingLine)
+			header = true
+			continue
+
+		case IRKindIdent:
+			var a []byte
+			// discard ancillary
+			if a, _, err = nextUint32(r, pos); err != nil {
+				break
+			}
+			var sum Checksum
+			if _, sum, err = nextIdent(r, pos); err != nil {
+				break
+			}
+
+			lines = append(lines, asmOutLine{p, 4, int64(kind), a, 1, "id  ", Encode(sum)})
+			continue
+		case IRKindUint32:
+			var i uint32
+			var bi []byte
+			if bi, i, err = nextUint32(r, pos); err != nil {
+				break
+			}
+			lines = append(lines, asmOutLine{p, 4, int64(kind), bi, 1, "int ", strconv.FormatUint(uint64(i), 10)})
+		case IRKindString:
+			var l uint32
+			var bl []byte
+			if bl, l, err = nextUint32(r, pos); err != nil {
+				break
+			}
+			s := make([]byte, l+(wordSize-(l)%wordSize)%wordSize)
+			var n int
+			if n, err = r.Read(s); err != nil {
+				break
+			}
+			*pos = *pos + n
+
+			lines = append(lines, asmOutLine{p, 4, int64(kind), bl, 1, "str ", strconv.Quote(string(s[:l]))})
+			continue
+		default:
+			var bi []byte
+			if bi, _, err = nextUint32(r, pos); err != nil {
+				break
+			}
+			lines = append(lines, asmOutLine{p, 4, int64(kind), bi, 1, "????", ""})
+		}
+	}
+	if err != io.EOF {
+		return
+	}
+	err = nil
+	for _, line := range lines {
+		if raw {
+			if line.pos != -1 {
+				sb.WriteString(fmt.Sprintf("%s\t%s\n", line.kind, line.value))
+			}
+		} else {
+			if line.pos == -1 {
+				sb.WriteString("\n")
+			} else if line.word == 4 {
+				sb.WriteString(fmt.Sprintf("%06x:  %04x %04x%s          %s  %s\n", line.pos, binary.LittleEndian.AppendUint32(nil, uint32(line.kindData)), line.valueData, headerSpacing(showHeader), line.kind, line.value))
+			} else {
+				kind := binary.LittleEndian.AppendUint64(nil, uint64(line.kindData))
+				value := line.valueData
+				if len(value) == 8 {
+					sb.WriteString(fmt.Sprintf("%06x:  %04x %04x %04x %04x      %s  %s\n", line.pos, kind[:4], kind[4:], value[:4], value[4:], line.kind, line.value))
+				} else {
+					sb.WriteString(fmt.Sprintf("%06x:  %04x %04x                        %s  %s\n", line.pos, kind[:4], kind[4:], line.kind, line.value))
+				}
+
+			}
+		}
+
+	}
+	return sb.String(), err
+}
+func nextUint32(r io.Reader, pos *int) ([]byte, uint32, error) {
+	i := make([]byte, 4)
+	_, err := r.Read(i)
+	if err != nil {
+		return i, 0, err
+	}
+	p := *pos + 4
+	*pos = p
+	return i, binary.LittleEndian.Uint32(i), nil
+}
+func nextUint64(r io.Reader, pos *int) ([]byte, uint64, error) {
+	i := make([]byte, 8)
+	_, err := r.Read(i)
+	if err != nil {
+		return i, 0, err
+	}
+	p := *pos + 8
+	*pos = p
+	return i, binary.LittleEndian.Uint64(i), nil
+}
+func nextIdent(r io.Reader, pos *int) ([]byte, Checksum, error) {
+	i := make([]byte, 48)
+	if _, err := r.Read(i); err != nil {
+		return i, Checksum{}, err
+	}
+	p := *pos + 48
+	*pos = p
+	return i, Checksum(i), nil
+}
+func intToKind(i uint64) string {
+	switch Kind(i) {
+	case KindHTTPGet:
+		return "http"
+	case KindTar:
+		return "tar "
+	case KindExec:
+		return "exec"
+	case KindExecNet:
+		return "exen"
+	case KindFile:
+		return "file"
+	default:
+		return fmt.Sprintf("$%d  ", i-KindCustomOffset)
+	}
+}
+func headerSpacing(showHeader bool) string {
+	if showHeader {
+		return "              "
+	}
+
+	return ""
+}

internal/rosa/meson.go

@@ -10,26 +10,46 @@ import (
 func (t Toolchain) newMeson() (pkg.Artifact, string) {
 	const (
 		version  = "1.11.0"
-		checksum = "b7oo3U_cklhzsTfsyYsjPGyeEufiS-Pm06JPLzodseS125Ach62ZBly7R6dSDiAc"
+		checksum = "QJolMPzypTiS65GReSNPPlkUjHI6b1EDpZ-avIk3n6b6TQ93KfUM57DVUpY97Hf7"
 	)
-	return t.New("meson-"+version, 0, []pkg.Artifact{
-		t.Load(Zlib),
-		t.Load(Python),
-		t.Load(Setuptools),
-	}, nil, nil, `
-cd /usr/src/meson
-chmod -R +w meson.egg-info
-python3 setup.py \
-	install \
-	--prefix=/system \
-	--root=/work
-`, pkg.Path(AbsUsrSrc.Append("meson"), true, newFromGitHubRelease(
+	return t.NewPackage("meson", version, newFromGitHub(
 		"mesonbuild/meson",
 		version,
-		"meson-"+version+".tar.gz",
 		checksum,
-		pkg.TarGzip,
-	))), version
+	), &PackageAttr{
+		Env: []string{
+			"CMAKE_MAKE_PROGRAM=ninja",
+		},
+	}, &PipHelper{
+		EnterSource: true,
+		Script: `
+cd 'test cases'
+rm -rf \
+	'common/32 has header' \
+	'common/66 vcstag' \
+	'common/153 wrap file should not failed' \
+	'common/184 openmp' \
+	'common/189 check header' \
+	'linuxlike/6 subdir include order' \
+	'linuxlike/9 compiler checks with dependencies' \
+	'linuxlike/13 cmake dependency' \
+	'frameworks/15 llvm' \
+	'frameworks/29 blocks'
+cd ..
+
+python3 ./run_project_tests.py \
+	-v \
+	` + jobsFlagE + ` \
+	--failfast \
+	--backend=ninja
+`,
+	},
+		Setuptools,
+		PkgConfig,
+		CMake,
+		Ninja,
+		PythonPyTest,
+	), version
 }
 func init() {
 	artifactsM[Meson] = Metadata{

internal/rosa/python.go

@@ -81,6 +81,62 @@ func init() {
 	}
 }
 
+// PipHelper is the [Python] pip packaging helper.
+type PipHelper struct {
+	// Whether to omit --no-build-isolation.
+	BuildIsolation bool
+	// Whether to enter source after install.
+	EnterSource bool
+	// Runs after install.
+	Script string
+}
+
+var _ Helper = new(PipHelper)
+
+// extra returns python.
+func (*PipHelper) extra(int) P { return P{Python} }
+
+// wantsChmod returns true.
+func (*PipHelper) wantsChmod() bool { return true }
+
+// wantsWrite is equivalent to wantsChmod.
+func (attr *PipHelper) wantsWrite() bool { return attr.wantsChmod() }
+
+// scriptEarly is a noop.
+func (*PipHelper) scriptEarly() string { return "" }
+
+// createDir returns false.
+func (*PipHelper) createDir() bool { return false }
+
+// wantsDir requests a new directory in TMPDIR.
+func (*PipHelper) wantsDir() string { return `"$(mktemp -d)"` }
+
+// script generates the pip3 install command.
+func (attr *PipHelper) script(name string) string {
+	if attr == nil {
+		attr = new(PipHelper)
+	}
+
+	var extra string
+	if !attr.BuildIsolation {
+		extra += `
+	--no-build-isolation \`
+	}
+
+	script := attr.Script
+	if attr.EnterSource {
+		script = "cd '/usr/src/" + name + "'\n" + script
+	}
+
+	return `
+pip3 install \
+	--no-index \
+	--prefix=/system \
+	--root=/work \` + extra + `
+	'/usr/src/` + name + `'
+` + script
+}
+
 // newViaPip installs a pip wheel from a url.
 func (t Toolchain) newViaPip(
 	name, version, url, checksum string,
@@ -134,18 +190,12 @@ func (t Toolchain) newSetuptools() (pkg.Artifact, string) {
 		version  = "82.0.1"
 		checksum = "nznP46Tj539yqswtOrIM4nQgwLA1h-ApKX7z7ghazROCpyF5swtQGwsZoI93wkhc"
 	)
-	return t.New("setuptools-"+version, 0, t.AppendPresets(nil,
-		Python,
-	), nil, nil, `
-pip3 install \
-	--no-index \
-	--prefix=/system \
-	--root=/work \
-	/usr/src/setuptools
-`, pkg.Path(AbsUsrSrc.Append("setuptools"), true, newFromGitHub(
+	return t.NewPackage("setuptools", version, newFromGitHub(
 		"pypa/setuptools",
 		"v"+version, checksum,
-	))), version
+	), nil, &PipHelper{
+		BuildIsolation: true,
+	}), version
 }
 func init() {
 	artifactsM[Setuptools] = Metadata{