package rosa

import "hakurei.app/internal/pkg"

func (t Toolchain) newM4() pkg.Artifact {
	const (
		version  = "1.4.20"
		checksum = "RT0_L3m4Co86bVBY3lCFAEs040yI1WdeNmRylFpah8IZovTm6O4wI7qiHJN3qsW9"
	)
	return t.NewViaMake("m4", version, pkg.NewHTTPGetTar(
		nil, "https://ftpmirror.gnu.org/gnu/m4/m4-"+version+".tar.bz2",
		mustDecode(checksum),
		pkg.TarBzip2,
	), &MakeAttr{
		Writable: true,
		ScriptEarly: `
cd /usr/src/m4
chmod +w tests/test-c32ispunct.sh && echo '#!/bin/sh' > tests/test-c32ispunct.sh
`,
	},
		t.Load(Diffutils),
	)
}
func init() { artifactsF[M4] = Toolchain.newM4 }

func (t Toolchain) newSed() pkg.Artifact {
	const (
		version  = "4.9"
		checksum = "pe7HWH4PHNYrazOTlUoE1fXmhn2GOPFN_xE62i0llOr3kYGrH1g2_orDz0UtZ9Nt"
	)
	return t.NewViaMake("sed", version, pkg.NewHTTPGetTar(
		nil, "https://ftpmirror.gnu.org/gnu/sed/sed-"+version+".tar.gz",
		mustDecode(checksum),
		pkg.TarGzip,
	), nil,
		t.Load(Diffutils),
	)
}
func init() { artifactsF[Sed] = Toolchain.newSed }

func (t Toolchain) newAutoconf() pkg.Artifact {
	const (
		version  = "2.72"
		checksum = "-c5blYkC-xLDer3TWEqJTyh1RLbOd1c5dnRLKsDnIrg_wWNOLBpaqMY8FvmUFJ33"
	)
	return t.NewViaMake("autoconf", version, pkg.NewHTTPGetTar(
		nil, "https://ftpmirror.gnu.org/gnu/autoconf/autoconf-"+version+".tar.gz",
		mustDecode(checksum),
		pkg.TarGzip,
	), &MakeAttr{
		Make: []string{
			`TESTSUITEFLAGS="-j$(nproc)"`,
		},
		Flag: TExclusive,
	},
		t.Load(M4),
		t.Load(Perl),
		t.Load(Bash),
		t.Load(Diffutils),
	)
}
func init() { artifactsF[Autoconf] = Toolchain.newAutoconf }

func (t Toolchain) newAutomake() pkg.Artifact {
	const (
		version  = "1.18.1"
		checksum = "FjvLG_GdQP7cThTZJLDMxYpRcKdpAVG-YDs1Fj1yaHlSdh_Kx6nRGN14E0r_BjcG"
	)
	return t.NewViaMake("automake", version, pkg.NewHTTPGetTar(
		nil, "https://ftpmirror.gnu.org/gnu/automake/automake-"+version+".tar.gz",
		mustDecode(checksum),
		pkg.TarGzip,
	), &MakeAttr{
		Writable: true,
		ScriptEarly: `
cd /usr/src/automake

test_disable() { chmod +w "$2" && echo "$1" > "$2"; }

test_disable '#!/bin/sh' t/objcxx-minidemo.sh
test_disable '#!/bin/sh' t/objcxx-deps.sh

test_disable '#!/bin/sh' t/dist-no-built-sources.sh
test_disable '#!/bin/sh' t/distname.sh
test_disable '#!/bin/sh' t/pr9.sh
`,
	},
		t.Load(M4),
		t.Load(Perl),
		t.Load(Grep),
		t.Load(Gzip),
		t.Load(Autoconf),
		t.Load(Diffutils),
	)
}
func init() { artifactsF[Automake] = Toolchain.newAutomake }

func (t Toolchain) newLibtool() pkg.Artifact {
	const (
		version  = "2.5.4"
		checksum = "pa6LSrQggh8mSJHQfwGjysAApmZlGJt8wif2cCLzqAAa2jpsTY0jZ-6stS3BWZ2Q"
	)
	return t.NewViaMake("libtool", version, pkg.NewHTTPGetTar(
		nil, "https://ftpmirror.gnu.org/gnu/libtool/libtool-"+version+".tar.gz",
		mustDecode(checksum),
		pkg.TarGzip,
	), &MakeAttr{
		Make: []string{
			`TESTSUITEFLAGS=32`,
		},
	},
		t.Load(M4),
		t.Load(Diffutils),
	)
}
func init() { artifactsF[Libtool] = Toolchain.newLibtool }

func (t Toolchain) newGzip() pkg.Artifact {
	const (
		version  = "1.14"
		checksum = "NWhjUavnNfTDFkZJyAUonL9aCOak8GVajWX2OMlzpFnuI0ErpBFyj88mz2xSjz0q"
	)
	return t.NewViaMake("gzip", version, pkg.NewHTTPGetTar(
		nil, "https://ftpmirror.gnu.org/gnu/gzip/gzip-"+version+".tar.gz",
		mustDecode(checksum),
		pkg.TarGzip,
	), &MakeAttr{
		// dependency loop
		SkipCheck: true,
	})
}
func init() { artifactsF[Gzip] = Toolchain.newGzip }

func (t Toolchain) newGettext() pkg.Artifact {
	const (
		version  = "1.0"
		checksum = "3MasKeEdPeFEgWgzsBKk7JqWqql1wEMbgPmzAfs-mluyokoW0N8oQVxPQoOnSdgC"
	)
	return t.NewViaMake("gettext", version, pkg.NewHTTPGetTar(
		nil, "https://ftpmirror.gnu.org/gnu/gettext/gettext-"+version+".tar.gz",
		mustDecode(checksum),
		pkg.TarGzip,
	), &MakeAttr{
		Writable: true,
		ScriptEarly: `
cd /usr/src/gettext
test_disable() { chmod +w "$2" && echo "$1" > "$2"; }

test_disable '#!/bin/sh' gettext-tools/tests/msgcat-22
test_disable '#!/bin/sh' gettext-tools/tests/msgconv-2
test_disable '#!/bin/sh' gettext-tools/tests/msgconv-8
test_disable '#!/bin/sh' gettext-tools/tests/xgettext-python-3
test_disable '#!/bin/sh' gettext-tools/tests/msgmerge-compendium-6
test_disable '#!/bin/sh' gettext-tools/tests/gettextpo-1
test_disable '#!/bin/sh' gettext-tools/tests/format-c-5
test_disable '#!/bin/sh' gettext-tools/gnulib-tests/test-c32ispunct.sh
test_disable 'int main(){return 0;}' gettext-tools/gnulib-tests/test-stdcountof-h.c

touch gettext-tools/autotools/archive.dir.tar
`,
	},
		t.Load(Diffutils),
		t.Load(Gzip),
		t.Load(Sed),

		t.Load(KernelHeaders),
	)
}
func init() { artifactsF[Gettext] = Toolchain.newGettext }

func (t Toolchain) newDiffutils() pkg.Artifact {
	const (
		version  = "3.12"
		checksum = "9J5VAq5oA7eqwzS1Yvw-l3G5o-TccUrNQR3PvyB_lgdryOFAfxtvQfKfhdpquE44"
	)
	return t.NewViaMake("diffutils", version, pkg.NewHTTPGetTar(
		nil, "https://ftpmirror.gnu.org/gnu/diffutils/diffutils-"+version+".tar.gz",
		mustDecode(checksum),
		pkg.TarGzip,
	), &MakeAttr{
		Writable: true,
		ScriptEarly: `
cd /usr/src/diffutils
test_disable() { chmod +w "$2" && echo "$1" > "$2"; }

test_disable '#!/bin/sh' gnulib-tests/test-c32ispunct.sh
test_disable 'int main(){return 0;}' gnulib-tests/test-c32ispunct.c
test_disable '#!/bin/sh' tests/cmp
`,
		Flag: TEarly,
	})
}
func init() { artifactsF[Diffutils] = Toolchain.newDiffutils }

func (t Toolchain) newPatch() pkg.Artifact {
	const (
		version  = "2.8"
		checksum = "MA0BQc662i8QYBD-DdGgyyfTwaeALZ1K0yusV9rAmNiIsQdX-69YC4t9JEGXZkeR"
	)
	return t.NewViaMake("patch", version, pkg.NewHTTPGetTar(
		nil, "https://ftpmirror.gnu.org/gnu/patch/patch-"+version+".tar.gz",
		mustDecode(checksum),
		pkg.TarGzip,
	), &MakeAttr{
		Writable: true,
		ScriptEarly: `
cd /usr/src/patch
test_disable() { chmod +w "$2" && echo "$1" > "$2"; }

test_disable '#!/bin/sh' tests/ed-style
test_disable '#!/bin/sh' tests/need-filename
`,
		Flag: TEarly,
	})
}
func init() { artifactsF[Patch] = Toolchain.newPatch }

func (t Toolchain) newBash() pkg.Artifact {
	const (
		version  = "5.3"
		checksum = "4LQ_GRoB_ko-Ih8QPf_xRKA02xAm_TOxQgcJLmFDT6udUPxTAWrsj-ZNeuTusyDq"
	)
	return t.NewViaMake("bash", version, pkg.NewHTTPGetTar(
		nil, "https://ftpmirror.gnu.org/gnu/bash/bash-"+version+".tar.gz",
		mustDecode(checksum),
		pkg.TarGzip,
	), &MakeAttr{
		Script: "ln -s bash /work/system/bin/sh\n",
		Configure: [][2]string{
			{"without-bash-malloc"},
		},
		Flag: TEarly,
	})
}
func init() { artifactsF[Bash] = Toolchain.newBash }

func (t Toolchain) newCoreutils() pkg.Artifact {
	const (
		version  = "9.9"
		checksum = "B1_TaXj1j5aiVIcazLWu8Ix03wDV54uo2_iBry4qHG6Y-9bjDpUPlkNLmU_3Nvw6"
	)
	return t.NewViaMake("coreutils", version, pkg.NewHTTPGetTar(
		nil, "https://ftpmirror.gnu.org/gnu/coreutils/coreutils-"+version+".tar.gz",
		mustDecode(checksum),
		pkg.TarGzip,
	), &MakeAttr{
		Writable: true,
		ScriptEarly: `
cd /usr/src/coreutils
test_disable() { chmod +w "$2" && echo "$1" > "$2"; }

test_disable '#!/bin/sh' gnulib-tests/test-c32ispunct.sh
test_disable '#!/bin/sh' tests/split/line-bytes.sh
test_disable '#!/bin/sh' tests/dd/no-allocate.sh
test_disable 'int main(){return 0;}' gnulib-tests/test-chown.c
test_disable 'int main(){return 0;}' gnulib-tests/test-fchownat.c
test_disable 'int main(){return 0;}' gnulib-tests/test-lchown.c
`,
		Flag: TEarly,
	},
		t.Load(Perl),
		t.Load(Bash),

		t.Load(KernelHeaders),
	)
}
func init() { artifactsF[Coreutils] = Toolchain.newCoreutils }

func (t Toolchain) newGperf() pkg.Artifact {
	const (
		version  = "3.3"
		checksum = "RtIy9pPb_Bb8-31J2Nw-rRGso2JlS-lDlVhuNYhqR7Nt4xM_nObznxAlBMnarJv7"
	)
	return t.NewViaMake("gperf", version, pkg.NewHTTPGetTar(
		nil, "https://ftpmirror.gnu.org/gperf/gperf-"+version+".tar.gz",
		mustDecode(checksum),
		pkg.TarGzip,
	), nil,
		t.Load(Diffutils),
	)
}
func init() { artifactsF[Gperf] = Toolchain.newGperf }

func (t Toolchain) newGawk() pkg.Artifact {
	const (
		version  = "5.3.2"
		checksum = "uIs0d14h_d2DgMGYwrPtegGNyt_bxzG3D6Fe-MmExx_pVoVkQaHzrtmiXVr6NHKk"
	)
	return t.NewViaMake("gawk", version, pkg.NewHTTPGetTar(
		nil, "https://ftpmirror.gnu.org/gnu/gawk/gawk-"+version+".tar.gz",
		mustDecode(checksum),
		pkg.TarGzip,
	), &MakeAttr{
		Flag: TEarly,

		// dependency loop
		SkipCheck: true,
	})
}
func init() { artifactsF[Gawk] = Toolchain.newGawk }

func (t Toolchain) newGrep() pkg.Artifact {
	const (
		version  = "3.12"
		checksum = "qMB4RjaPNRRYsxix6YOrjE8gyAT1zVSTy4nW4wKW9fqa0CHYAuWgPwDTirENzm_1"
	)
	return t.NewViaMake("grep", version, pkg.NewHTTPGetTar(
		nil, "https://ftpmirror.gnu.org/gnu/grep/grep-"+version+".tar.gz",
		mustDecode(checksum),
		pkg.TarGzip,
	), &MakeAttr{
		Writable: true,
		ScriptEarly: `
cd /usr/src/grep

test_disable() { chmod +w "$2" && echo "$1" > "$2"; }

test_disable '#!/bin/sh' gnulib-tests/test-c32ispunct.sh
test_disable 'int main(){return 0;}' gnulib-tests/test-c32ispunct.c
`,
	},
		t.Load(Diffutils),
	)
}
func init() { artifactsF[Grep] = Toolchain.newGrep }

func (t Toolchain) newFindutils() pkg.Artifact {
	const (
		version  = "4.10.0"
		checksum = "ZXABdNBQXL7QjTygynRRTdXYWxQKZ0Wn5eMd3NUnxR0xaS0u0VfcKoTlbo50zxv6"
	)
	return t.NewViaMake("findutils", version, pkg.NewHTTPGet(
		nil, "https://ftpmirror.gnu.org/gnu/findutils/findutils-"+version+".tar.xz",
		mustDecode(checksum),
	), &MakeAttr{
		SourceSuffix: ".tar.xz",
		ScriptEarly: `
cd /usr/src/
tar xf findutils.tar.xz
mv findutils-` + version + ` findutils

cd findutils
echo '#!/bin/sh' > gnulib-tests/test-c32ispunct.sh
echo 'int main(){return 0;}' > tests/xargs/test-sigusr.c
`,
	},
		t.Load(Diffutils),
		t.Load(XZ),
		t.Load(Sed),
	)
}
func init() { artifactsF[Findutils] = Toolchain.newFindutils }

func (t Toolchain) newBinutils() pkg.Artifact {
	const (
		version  = "2.45"
		checksum = "hlLtqqHDmzAT2OQVHaKEd_io2DGFvJkaeS-igBuK8bRRir7LUKGHgHYNkDVKaHTT"
	)
	return t.NewViaMake("binutils", version, pkg.NewHTTPGetTar(
		nil, "https://ftpmirror.gnu.org/gnu/binutils/binutils-"+version+".tar.bz2",
		mustDecode(checksum),
		pkg.TarBzip2,
	), &MakeAttr{
		ScriptConfigured: `
make "-j$(nproc)"
`,
	},
		t.Load(Bash),
	)
}
func init() { artifactsF[Binutils] = Toolchain.newBinutils }

func (t Toolchain) newGMP() pkg.Artifact {
	const (
		version  = "6.3.0"
		checksum = "yrgbgEDWKDdMWVHh7gPbVl56-sRtVVhfvv0M_LX7xMUUk_mvZ1QOJEAnt7g4i3k5"
	)
	return t.NewViaMake("gmp", version, pkg.NewHTTPGetTar(
		nil, "https://gcc.gnu.org/pub/gcc/infrastructure/"+
			"gmp-"+version+".tar.bz2",
		mustDecode(checksum),
		pkg.TarBzip2,
	), &MakeAttr{
		ScriptConfigured: `
make "-j$(nproc)"
`,
	},
		t.Load(M4),
	)
}
func init() { artifactsF[GMP] = Toolchain.newGMP }

func (t Toolchain) newMPFR() pkg.Artifact {
	const (
		version  = "4.2.2"
		checksum = "wN3gx0zfIuCn9r3VAn_9bmfvAYILwrRfgBjYSD1IjLqyLrLojNN5vKyQuTE9kA-B"
	)
	return t.NewViaMake("mpfr", version, pkg.NewHTTPGetTar(
		nil, "https://gcc.gnu.org/pub/gcc/infrastructure/"+
			"mpfr-"+version+".tar.bz2",
		mustDecode(checksum),
		pkg.TarBzip2,
	), nil,
		t.Load(GMP),
	)
}
func init() { artifactsF[MPFR] = Toolchain.newMPFR }

func (t Toolchain) newMPC() pkg.Artifact {
	const (
		version  = "1.3.1"
		checksum = "o8r8K9R4x7PuRx0-JE3-bC5jZQrtxGV2nkB773aqJ3uaxOiBDCID1gKjPaaDxX4V"
	)
	return t.NewViaMake("mpc", version, pkg.NewHTTPGetTar(
		nil, "https://gcc.gnu.org/pub/gcc/infrastructure/"+
			"mpc-"+version+".tar.gz",
		mustDecode(checksum),
		pkg.TarGzip,
	), nil,
		t.Load(GMP),
		t.Load(MPFR),
	)
}
func init() { artifactsF[MPC] = Toolchain.newMPC }

func (t Toolchain) newGCC() pkg.Artifact {
	const (
		version  = "15.2.0"
		checksum = "TXJ5WrbXlGLzy1swghQTr4qxgDCyIZFgJry51XEPTBZ8QYbVmFeB4lZbSMtPJ-a1"
	)
	return t.NewViaMake("gcc", version, t.NewPatchedSource(
		"gcc", version,
		pkg.NewHTTPGetTar(
			nil, "https://ftp.tsukuba.wide.ad.jp/software/gcc/releases/"+
				"gcc-"+version+"/gcc-"+version+".tar.gz",
			mustDecode(checksum),
			pkg.TarGzip,
		), true, [2]string{"musl-off64_t-loff_t", `diff --git a/libgo/sysinfo.c b/libgo/sysinfo.c
index 180f5c31d74..44d7ea73f7d 100644
--- a/libgo/sysinfo.c
+++ b/libgo/sysinfo.c
@@ -365,11 +365,7 @@ enum {
 typedef loff_t libgo_loff_t_type;
 #endif

-#if defined(HAVE_OFF64_T)
-typedef off64_t libgo_off_t_type;
-#else
 typedef off_t libgo_off_t_type;
-#endif

 // The following section introduces explicit references to types and
 // constants of interest to support bootstrapping libgo using a
`}, [2]string{"musl-legacy-lfs", `diff --git a/libgo/go/internal/syscall/unix/at_largefile.go b/libgo/go/internal/syscall/unix/at_largefile.go
index 82e0dcfd074..16151ecad1b 100644
--- a/libgo/go/internal/syscall/unix/at_largefile.go
+++ b/libgo/go/internal/syscall/unix/at_largefile.go
@@ -10,5 +10,5 @@ import (
 	"syscall"
 )

-//extern fstatat64
+//extern fstatat
 func fstatat(int32, *byte, *syscall.Stat_t, int32) int32
diff --git a/libgo/go/os/dir_largefile.go b/libgo/go/os/dir_largefile.go
index 1fc5ee0771f..0c6dffe1a75 100644
--- a/libgo/go/os/dir_largefile.go
+++ b/libgo/go/os/dir_largefile.go
@@ -11,5 +11,5 @@ package os

 import "syscall"

-//extern readdir64
+//extern readdir
 func libc_readdir(*syscall.DIR) *syscall.Dirent
diff --git a/libgo/go/syscall/libcall_glibc.go b/libgo/go/syscall/libcall_glibc.go
index 5c1ec483c75..5a1245ed44b 100644
--- a/libgo/go/syscall/libcall_glibc.go
+++ b/libgo/go/syscall/libcall_glibc.go
@@ -114,7 +114,7 @@ func Pipe2(p []int, flags int) (err error) {
 }

 //sys	sendfile(outfd int, infd int, offset *Offset_t, count int) (written int, err error)
-//sendfile64(outfd _C_int, infd _C_int, offset *Offset_t, count Size_t) Ssize_t
+//sendfile(outfd _C_int, infd _C_int, offset *Offset_t, count Size_t) Ssize_t

 func Sendfile(outfd int, infd int, offset *int64, count int) (written int, err error) {
 	if race.Enabled {
diff --git a/libgo/go/syscall/libcall_linux.go b/libgo/go/syscall/libcall_linux.go
index 03ca7261b59..ad21fd0b3ac 100644
--- a/libgo/go/syscall/libcall_linux.go
+++ b/libgo/go/syscall/libcall_linux.go
@@ -158,7 +158,7 @@ func Reboot(cmd int) (err error) {
 //adjtimex(buf *Timex) _C_int

 //sys	Fstatfs(fd int, buf *Statfs_t) (err error)
-//fstatfs64(fd _C_int, buf *Statfs_t) _C_int
+//fstatfs(fd _C_int, buf *Statfs_t) _C_int

 func Gettid() (tid int) {
 	r1, _, _ := Syscall(SYS_GETTID, 0, 0, 0)
@@ -245,7 +245,7 @@ func Splice(rfd int, roff *int64, wfd int, woff *int64, len int, flags int) (n i
 }

 //sys	Statfs(path string, buf *Statfs_t) (err error)
-//statfs64(path *byte, buf *Statfs_t) _C_int
+//statfs(path *byte, buf *Statfs_t) _C_int

 //sysnb	Sysinfo(info *Sysinfo_t) (err error)
 //sysinfo(info *Sysinfo_t) _C_int
diff --git a/libgo/go/syscall/libcall_posix_largefile.go b/libgo/go/syscall/libcall_posix_largefile.go
index f90055bb29a..334212f0af1 100644
--- a/libgo/go/syscall/libcall_posix_largefile.go
+++ b/libgo/go/syscall/libcall_posix_largefile.go
@@ -10,40 +10,40 @@
 package syscall

 //sys	Creat(path string, mode uint32) (fd int, err error)
-//creat64(path *byte, mode Mode_t) _C_int
+//creat(path *byte, mode Mode_t) _C_int

 //sys	Fstat(fd int, stat *Stat_t) (err error)
-//fstat64(fd _C_int, stat *Stat_t) _C_int
+//fstat(fd _C_int, stat *Stat_t) _C_int

 //sys	Ftruncate(fd int, length int64) (err error)
-//ftruncate64(fd _C_int, length Offset_t) _C_int
+//ftruncate(fd _C_int, length Offset_t) _C_int

 //sysnb	Getrlimit(resource int, rlim *Rlimit) (err error)
-//getrlimit64(resource _C_int, rlim *Rlimit) _C_int
+//getrlimit(resource _C_int, rlim *Rlimit) _C_int

 //sys	Lstat(path string, stat *Stat_t) (err error)
-//lstat64(path *byte, stat *Stat_t) _C_int
+//lstat(path *byte, stat *Stat_t) _C_int

 //sys	mmap(addr uintptr, length uintptr, prot int, flags int, fd int, offset int64) (xaddr uintptr, err error)
-//mmap64(addr *byte, length Size_t, prot _C_int, flags _C_int, fd _C_int, offset Offset_t) *byte
+//mmap(addr *byte, length Size_t, prot _C_int, flags _C_int, fd _C_int, offset Offset_t) *byte

 //sys	Open(path string, mode int, perm uint32) (fd int, err error)
-//__go_open64(path *byte, mode _C_int, perm Mode_t) _C_int
+//__go_open(path *byte, mode _C_int, perm Mode_t) _C_int

 //sys	Pread(fd int, p []byte, offset int64) (n int, err error)
-//pread64(fd _C_int, buf *byte, count Size_t, offset Offset_t) Ssize_t
+//pread(fd _C_int, buf *byte, count Size_t, offset Offset_t) Ssize_t

 //sys	Pwrite(fd int, p []byte, offset int64) (n int, err error)
-//pwrite64(fd _C_int, buf *byte, count Size_t, offset Offset_t) Ssize_t
+//pwrite(fd _C_int, buf *byte, count Size_t, offset Offset_t) Ssize_t

 //sys	Seek(fd int, offset int64, whence int) (off int64, err error)
-//lseek64(fd _C_int, offset Offset_t, whence _C_int) Offset_t
+//lseek(fd _C_int, offset Offset_t, whence _C_int) Offset_t

 //sysnb	Setrlimit(resource int, rlim *Rlimit) (err error)
-//setrlimit64(resource int, rlim *Rlimit) _C_int
+//setrlimit(resource int, rlim *Rlimit) _C_int

 //sys	Stat(path string, stat *Stat_t) (err error)
-//stat64(path *byte, stat *Stat_t) _C_int
+//stat(path *byte, stat *Stat_t) _C_int

 //sys	Truncate(path string, length int64) (err error)
-//truncate64(path *byte, length Offset_t) _C_int
+//truncate(path *byte, length Offset_t) _C_int
diff --git a/libgo/runtime/go-varargs.c b/libgo/runtime/go-varargs.c
index f84860891e6..7efc9615985 100644
--- a/libgo/runtime/go-varargs.c
+++ b/libgo/runtime/go-varargs.c
@@ -84,7 +84,7 @@ __go_ioctl_ptr (int d, int request, void *arg)
 int
 __go_open64 (char *path, int mode, mode_t perm)
 {
-  return open64 (path, mode, perm);
+  return open (path, mode, perm);
 }

 #endif
`}), &MakeAttr{
		ScriptEarly: `
ln -s system/lib /
ln -s system/lib /work/
`,
		Configure: [][2]string{
			{"disable-multilib"},
			{"with-multilib-list", `""`},
			{"enable-default-pie"},
			{"disable-nls"},
			{"with-gnu-as"},
			{"with-gnu-ld"},
			{"with-system-zlib"},
			{"enable-languages", "c,c++,go"},
			{"with-native-system-header-dir", "/system/include"},
		},
		Make: []string{
			"BOOT_CFLAGS='-O2 -g'",
			"bootstrap",
		},

		// This toolchain is hacked to pieces, it is not expected to ever work
		// well in its current state. That does not matter as long as the
		// toolchain it produces passes its own test suite.
		SkipCheck: true,

		// GCC spends most of its time in its many configure scripts, however
		// it also saturates the CPU for a consequential amount of time.
		Flag: TExclusive,
	},
		t.Load(Binutils),

		t.Load(GMP),
		t.Load(MPFR),
		t.Load(MPC),

		t.Load(Zlib),
		t.Load(Libucontext),
		t.Load(KernelHeaders),
	)
}
func init() { artifactsF[gcc] = Toolchain.newGCC }