Ophestra
56567307ec
All checks were successful
Test / Create distribution (push) Successful in 2m21s
Test / Sandbox (push) Successful in 5m17s
Test / Hakurei (push) Successful in 10m39s
Test / ShareFS (push) Successful in 12m32s
Test / Hakurei (race detector) (push) Successful in 3m28s
Test / Hpkg (push) Successful in 5m42s
Test / Sandbox (race detector) (push) Successful in 2m20s
Test / Flake checks (push) Successful in 1m44s
Initially, libarchive was going to be used, but its test suite simply does not want to work under musl, not even with libiconv. The ticket last discussing this ceased any activity in 2020. Signed-off-by: Ophestra <cat@gensokyo.uk>
724 lines
20 KiB
Go
724 lines
20 KiB
Go
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) newBison() pkg.Artifact {
|
|
const (
|
|
version = "3.8.2"
|
|
checksum = "BhRM6K7URj1LNOkIDCFDctSErLS-Xo5d9ba9seg10o6ACrgC1uNhED7CQPgIY29Y"
|
|
)
|
|
return t.NewViaMake("bison", version, pkg.NewHTTPGetTar(
|
|
nil, "https://ftpmirror.gnu.org/gnu/bison/bison-"+version+".tar.gz",
|
|
mustDecode(checksum),
|
|
pkg.TarGzip,
|
|
), nil,
|
|
t.Load(M4),
|
|
t.Load(Diffutils),
|
|
t.Load(Sed),
|
|
)
|
|
}
|
|
func init() { artifactsF[Bison] = Toolchain.newBison }
|
|
|
|
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) newTexinfo() pkg.Artifact {
|
|
const (
|
|
version = "7.2"
|
|
checksum = "9EelM5b7QGMAY5DKrAm_El8lofBGuFWlaBPSBhh7l_VQE8054MBmC0KBvGrABqjv"
|
|
)
|
|
return t.NewViaMake("texinfo", version, pkg.NewHTTPGetTar(
|
|
nil, "https://ftpmirror.gnu.org/gnu/texinfo/texinfo-"+version+".tar.gz",
|
|
mustDecode(checksum),
|
|
pkg.TarGzip,
|
|
), &MakeAttr{
|
|
// nonstandard glibc extension
|
|
SkipCheck: true,
|
|
},
|
|
t.Load(Perl),
|
|
)
|
|
}
|
|
func init() { artifactsF[Texinfo] = Toolchain.newTexinfo }
|
|
|
|
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) newBC() pkg.Artifact {
|
|
const (
|
|
version = "1.08.2"
|
|
checksum = "8h6f3hjV80XiFs6v9HOPF2KEyg1kuOgn5eeFdVspV05ODBVQss-ey5glc8AmneLy"
|
|
)
|
|
return t.NewViaMake("bc", version, t.NewPatchedSource(
|
|
"bc", version, pkg.NewHTTPGetTar(
|
|
nil, "https://ftpmirror.gnu.org/gnu/bc/bc-"+version+".tar.gz",
|
|
mustDecode(checksum),
|
|
pkg.TarGzip,
|
|
), false,
|
|
), &MakeAttr{
|
|
Writable: true,
|
|
},
|
|
t.Load(Perl),
|
|
t.Load(Texinfo),
|
|
)
|
|
}
|
|
func init() { artifactsF[BC] = Toolchain.newBC }
|
|
|
|
func (t Toolchain) newLibiconv() pkg.Artifact {
|
|
const (
|
|
version = "1.18"
|
|
checksum = "iV5q3VxP5VPdJ-X7O5OQI4fGm8VjeYb5viLd1L3eAHg26bbHb2_Qn63XPF3ucVZr"
|
|
)
|
|
return t.NewViaMake("libiconv", version, pkg.NewHTTPGetTar(
|
|
nil, "https://ftpmirror.gnu.org/gnu/libiconv/libiconv-"+version+".tar.gz",
|
|
mustDecode(checksum),
|
|
pkg.TarGzip,
|
|
), nil)
|
|
}
|
|
func init() { artifactsF[Libiconv] = Toolchain.newLibiconv }
|
|
|
|
func (t Toolchain) newTar() pkg.Artifact {
|
|
const (
|
|
version = "1.35"
|
|
checksum = "zSaoSlVUDW0dSfm4sbL4FrXLFR8U40Fh3zY5DWhR5NCIJ6GjU6Kc4VZo2-ZqpBRA"
|
|
)
|
|
return t.NewViaMake("tar", version, pkg.NewHTTPGetTar(
|
|
nil, "https://ftpmirror.gnu.org/gnu/tar/tar-"+version+".tar.gz",
|
|
mustDecode(checksum),
|
|
pkg.TarGzip,
|
|
), &MakeAttr{
|
|
Env: []string{
|
|
// very expensive
|
|
"TARTEST_SKIP_LARGE_FILES=1",
|
|
},
|
|
Configure: [][2]string{
|
|
{"disable-acl"},
|
|
{"without-posix-acls"},
|
|
{"without-xattrs"},
|
|
},
|
|
Make: []string{
|
|
`TESTSUITEFLAGS="-j$(nproc)"`,
|
|
},
|
|
},
|
|
t.Load(Diffutils),
|
|
|
|
t.Load(Gzip),
|
|
t.Load(Bzip2),
|
|
t.Load(Zstd),
|
|
)
|
|
}
|
|
func init() { artifactsF[Tar] = Toolchain.newTar }
|
|
|
|
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 }
|