[release-branch.go1.16-security] go1.16.1

Change-Id: I4999d72caf9462554a2a6f1d761244cafec34718 Reviewed-on: https://team-review.git.corp.google.com/c/golang/go-private/+/1014541 Reviewed-by: Katie Hockman <katiehockman@google.com>
[release-branch.go1.16-security] archive/zip: fix panic in Reader.Open
2026-01-30 15:42:04 +03:00 · 2021-03-10 14:25:03 +00:00 · 2021-03-09 17:55:16 +00:00 · 2021-03-09 17:55:05 +00:00 · 2021-02-16 18:08:40 +00:00 · 2021-02-16 12:10:50 -05:00
4341 changed files with 120503 additions and 266875 deletions
--- a/.gitignore
+++ b/.gitignore
@@ -37,7 +37,6 @@ _testmain.go
 /src/cmd/internal/objabi/zbootstrap.go
 /src/go/build/zcgo.go
 /src/go/doc/headscan
-/src/internal/buildcfg/zbootstrap.go
 /src/runtime/internal/sys/zversion.go
 /src/unicode/maketables
 /test.out
--- a/7
+++ b/7
@@ -41,7 +41,7 @@ Aeneas Rekkas (arekkas) <aeneas@ory.am>
 Afanasev Stanislav <phpprogger@gmail.com>
 Agis Anastasopoulos <agis.anast@gmail.com>
 Agniva De Sarker <agnivade@yahoo.co.in>
-Ahmed W. Mones <oneofone@gmail.com>
+Ahmed Wahed <oneofone@gmail.com>
 Ahmet Soormally <ahmet@mangomm.co.uk>
 Ahmy Yulrizka <yulrizka@gmail.com>
 Aiden Scandella <ai@uber.com>
@@ -145,7 +145,7 @@ Andy Davis <andy@bigandian.com>
 Andy Finkenstadt <afinkenstadt@zynga.com>
 Andy Lindeman <andy@lindeman.io>
 Andy Maloney <asmaloney@gmail.com>
-Andy Pan <panjf2000@gmail.com> <panjf2000@golangcn.org> <i@andypan.me>
+Andy Pan <panjf2000@gmail.com>
 Andy Walker <walkeraj@gmail.com>
 Anfernee Yongkun Gui <anfernee.gui@gmail.com>
 Angelo Bulfone <mbulfone@gmail.com>
@@ -195,7 +195,7 @@ Ayanamist Yang <ayanamist@gmail.com>
 Aymerick Jéhanne <aymerick@jehanne.org>
 Azat Kaumov <kaumov.a.r@gmail.com>
 Baiju Muthukadan <baiju.m.mail@gmail.com>
-Baokun Lee <nototon@gmail.com> <bk@golangcn.org>
+Baokun Lee <nototon@gmail.com>
 Bartosz Grzybowski <melkorm@gmail.com>
 Bastian Ike <bastian.ike@gmail.com>
 Ben Burkert <ben@benburkert.com>
@@ -1425,7 +1425,6 @@ Wèi Cōngruì <crvv.mail@gmail.com>
 Wei Fu <fhfuwei@163.com>
 Wei Guangjing <vcc.163@gmail.com>
 Weichao Tang <tevic.tt@gmail.com>
-Weixie Cui <cuiweixie@gmail.com> <523516579@qq.com>
 Wembley G. Leach, Jr <wembley.gl@gmail.com>
 Will Faught <will.faught@gmail.com>
 Will Storey <will@summercat.com>
--- a/145
+++ b/145
@@ -33,7 +33,6 @@ Aaron Jacobs <jacobsa@google.com>
 Aaron Jensen <jensen.aaro@gmail.com>
 Aaron Kemp <kemp.aaron@gmail.com>
 Aaron Patterson <tenderlove@ruby-lang.org>
-Aaron Sheah <aaronsheah@gmail.com>
 Aaron Stein <aaronstein12@gmail.com>
 Aaron Torres <tcboox@gmail.com>
 Aaron Zinman <aaron@azinman.com>
@@ -48,7 +47,6 @@ Adam Harvey <aharvey@php.net>
 Adam Kisala <adam.kisala@gmail.com>
 Adam Langley <agl@golang.org>
 Adam Medzinski <adam.medzinski@gmail.com>
-Adam Mitha <adam.mitha@gmail.com>
 Adam Shannon <adamkshannon@gmail.com>
 Adam Shelton <aashelt90@gmail.com>
 Adam Sindelar <adamsh@google.com>
@@ -56,8 +54,6 @@ Adam Thomason <athomason@gmail.com>
 Adam Williams <pwnfactory@gmail.com>
 Adam Woodbeck <adam@woodbeck.net>
 Adarsh Ravichandran <adarshravichandran91@gmail.com>
-Adel Rodríguez <adel.rodriguez@leftfieldlabs.com>
-Adin Scannell <ascannell@google.com>
 Aditya Harindar <aditya.harindar@gmail.com>
 Aditya Mukerjee <dev@chimeracoder.net>
 Adrian Hesketh <adrianhesketh@hushmail.com>
@@ -71,8 +67,7 @@ Aeneas Rekkas (arekkas) <aeneas@ory.am>
 Afanasev Stanislav <phpprogger@gmail.com>
 Agis Anastasopoulos <agis.anast@gmail.com>
 Agniva De Sarker <agnivade@yahoo.co.in>
-Ahmed W. Mones <oneofone@gmail.com>
-Ahmet Aktürk <aakturk000@gmail.com>
+Ahmed Wahed <oneofone@gmail.com>
 Ahmet Alp Balkan <ahmetb@google.com>
 Ahmet Soormally <ahmet@mangomm.co.uk>
 Ahmy Yulrizka <yulrizka@gmail.com>
@@ -97,13 +92,11 @@ Alberto Bertogli <albertito@blitiri.com.ar>
 Alberto Donizetti <alb.donizetti@gmail.com>
 Alberto García Hierro <alberto@garciahierro.com> <alberto.garcia.hierro@gmail.com>
 Alec Benzer <alec.benzer@gmail.com>
-Alejandro García Montoro <alejandro.garciamontoro@gmail.com>
 Aleksa Sarai <cyphar@cyphar.com>
 Aleksandar Dezelin <dezelin@gmail.com>
 Aleksandr Lukinykh <a.lukinykh@xsolla.com>
 Aleksandr Razumov <ar@cydev.ru>
 Alekseev Artem <a.artem060@gmail.com>
-Aleksei Tirman <aleksei.tirman@jetbrains.com>
 Alessandro Arzilli <alessandro.arzilli@gmail.com>
 Alessandro Baffa <alessandro.baffa@gmail.com>
 Alex A Skinner <alex@lx.lc>
@@ -172,7 +165,6 @@ Ali Rizvi-Santiago <arizvisa@gmail.com>
 Aliaksandr Valialkin <valyala@gmail.com>
 Alice Merrick <amerrick@google.com>
 Alif Rachmawadi <subosito@gmail.com>
-Allan Guwatudde <guwats10@gmail.com>
 Allan Simon <allan.simon@supinfo.com>
 Allen Li <ayatane@google.com>
 Alok Menghrajani <alok.menghrajani@gmail.com>
@@ -180,7 +172,6 @@ Alwin Doss <alwindoss84@gmail.com>
 Aman Gupta <aman@tmm1.net>
 Amarjeet Anand <amarjeetanandsingh@gmail.com>
 Amir Mohammad Saied <amir@gluegadget.com>
-Amit Kumar <mittalmailbox@gmail.com>
 Amr Mohammed <merodiro@gmail.com>
 Amrut Joshi <amrut.joshi@gmail.com>
 An Long <aisk1988@gmail.com>
@@ -194,7 +185,6 @@ André Carvalho <asantostc@gmail.com>
 André Martins <aanm90@gmail.com>
 Andre Nathan <andrenth@gmail.com>
 Andrea Nodari <andrea.nodari91@gmail.com>
-Andrea Simonini <andrea.simonini@gmail.com>
 Andrea Spadaccini <spadaccio@google.com>
 Andreas Auernhammer <aead@mail.de>
 Andreas Jellinghaus <andreas@ionisiert.de> <anj@google.com>
@@ -250,11 +240,10 @@ Andy Davis <andy@bigandian.com>
 Andy Finkenstadt <afinkenstadt@zynga.com>
 Andy Lindeman <andy@lindeman.io>
 Andy Maloney <asmaloney@gmail.com>
-Andy Pan <panjf2000@gmail.com> <panjf2000@golangcn.org> <i@andypan.me>
+Andy Pan <panjf2000@gmail.com>
 Andy Walker <walkeraj@gmail.com>
 Andy Wang <cbeuw.andy@gmail.com>
 Andy Williams <andy@andy.xyz>
-Andy Zhao <andyzhao@google.com>
 Andzej Maciusovic <andzej.maciusovic@gmail.com>
 Anfernee Yongkun Gui <anfernee.gui@gmail.com>
 Angelo Bulfone <mbulfone@gmail.com>
@@ -280,7 +269,6 @@ Anton Kuklin <anton.a.kuklin@gmail.com>
 Antonin Amand <antonin.amand@gmail.com>
 Antonio Antelo <aantelov87@gmail.com>
 Antonio Bibiano <antbbn@gmail.com>
-Antonio Garcia <garcia.olais@gmail.com>
 Antonio Huete Jimenez <tuxillo@quantumachine.net>
 Antonio Murdaca <runcom@redhat.com>
 Antonio Troina <thoeni@gmail.com>
@@ -304,10 +292,8 @@ Artem Khvastunov <artem.khvastunov@jetbrains.com>
 Artem Kolin <artemkaxboy@gmail.com>
 Arthur Fabre <arthur@arthurfabre.com>
 Arthur Khashaev <arthur@khashaev.ru>
-Artur M. Wolff <artur.m.wolff@gmail.com>
 Artyom Pervukhin <artyom.pervukhin@gmail.com>
 Arvindh Rajesh Tamilmani <art@a-30.net>
-Ashish Bhate <ab.listsubs@gmail.com>
 Ashish Gandhi <ag@ashishgandhi.org>
 Asim Shankar <asimshankar@gmail.com>
 Assel Meher <asselmeher@gmail.com>
@@ -335,11 +321,10 @@ Azat Kaumov <kaumov.a.r@gmail.com>
 Baiju Muthukadan <baiju.m.mail@gmail.com>
 Balaram Makam <bmakam.qdt@qualcommdatacenter.com>
 Balazs Lecz <leczb@google.com>
-Baokun Lee <nototon@gmail.com> <bk@golangcn.org>
+Baokun Lee <nototon@gmail.com>
 Barnaby Keene <accounts@southcla.ws>
 Bartosz Grzybowski <melkorm@gmail.com>
 Bartosz Oler <brtsz@google.com>
-Bassam Ojeil <bojeil@google.com>
 Bastian Ike <bastian.ike@gmail.com>
 Ben Burkert <ben@benburkert.com>
 Ben Cartwright-Cox <Ben@Benjojo.co.uk>
@@ -347,7 +332,6 @@ Ben Eitzen <eitzenb@golang.org>
 Ben Fried <ben.fried@gmail.com>
 Ben Haines <bhainesva@gmail.com>
 Ben Hoyt <benhoyt@gmail.com>
-Ben Hutchings <ben.hutchings@essensium.com>
 Ben Kraft <benkraft@khanacademy.org>
 Ben Laurie <ben@links.org> <benl@google.com>
 Ben Lubar <ben.lubar@gmail.com>
@@ -446,7 +430,6 @@ Carl Henrik Lunde <chlunde@ifi.uio.no>
 Carl Jackson <carl@stripe.com>
 Carl Johnson <me@carlmjohnson.net>
 Carl Mastrangelo <notcarl@google.com>
-Carl Menezes <carleeto@gmail.com>
 Carl Shapiro <cshapiro@google.com> <cshapiro@golang.org>
 Carlisia Campos <carlisia@grokkingtech.io>
 Carlo Alberto Ferraris <cafxx@strayorange.com>
@@ -460,7 +443,6 @@ Carlos Iriarte <ciriarte@gmail.com>
 Carlos Souza <carloshrsouza@gmail.com>
 Carolyn Van Slyck <me@carolynvanslyck.com>
 Carrie Bynon <cbynon@gmail.com>
-Carson Hoffman <c@rsonhoffman.com>
 Cary Hull <chull@google.com>
 Case Nelson <case.nelson@gmail.com>
 Casey Callendrello <squeed@gmail.com>
@@ -480,12 +462,11 @@ Charles Kenney <charlesc.kenney@gmail.com>
 Charles L. Dorian <cldorian@gmail.com>
 Charles Lee <zombie.fml@gmail.com>
 Charles Weill <weill@google.com>
-Charlie Moog <moogcharlie@gmail.com>
 Charlotte Brandhorst-Satzkorn <catzkorn@gmail.com>
 Chauncy Cullitan <chauncyc@google.com>
 Chen Zhidong <njutczd@gmail.com>
 Chen Zhihan <energiehund@gmail.com>
-Cherry Mui <cherryyz@google.com>
+Cherry Zhang <cherryyz@google.com>
 Chew Choon Keat <choonkeat@gmail.com>
 Chiawen Chen <golopot@gmail.com>
 Chirag Sukhala <cchirag77@gmail.com>
@@ -535,7 +516,6 @@ Christopher Nelson <nadiasvertex@gmail.com>
 Christopher Nielsen <m4dh4tt3r@gmail.com>
 Christopher Redden <christopher.redden@gmail.com>
 Christopher Swenson <cswenson@google.com>
-Christopher Thomas <53317512+chrisssthomas@users.noreply.github.com>
 Christopher Wedgwood <cw@f00f.org>
 Christos Zoulas <christos@zoulas.com> <zoulasc@gmail.com>
 Christy Perez <christy@linux.vnet.ibm.com>
@@ -561,8 +541,6 @@ Cosmos Nicolaou <cnicolaou@google.com>
 Costin Chirvasuta <ctin@google.com>
 Craig Citro <craigcitro@google.com>
 Cristian Staretu <unclejacksons@gmail.com>
-Cristo García <cgg.code@gmail.com>
-cui fliter <imcusg@gmail.com>
 Cuihtlauac ALVARADO <cuihtlauac.alvarado@orange.com>
 Cuong Manh Le <cuong@orijtech.com>
 Curtis La Graff <curtis@lagraff.me>
@@ -582,7 +560,6 @@ Dan Callahan <dan.callahan@gmail.com>
 Dan Harrington <harringtond@google.com>
 Dan Jacques <dnj@google.com>
 Dan Johnson <computerdruid@google.com>
-Dan McArdle <dmcardle@google.com>
 Dan Peterson <dpiddy@gmail.com>
 Dan Pupius <dan@medium.com>
 Dan Scales <danscales@google.com>
@@ -634,7 +611,6 @@ Dave Russell <forfuncsake@gmail.com>
 David Anderson <danderson@google.com>
 David Barnett <dbarnett@google.com>
 David Benjamin <davidben@google.com>
-David Black <dblack@atlassian.com>
 David Bond <davidsbond93@gmail.com>
 David Brophy <dave@brophy.uk>
 David Bürgin <676c7473@gmail.com>
@@ -678,7 +654,6 @@ Davor Kapsa <davor.kapsa@gmail.com>
 Dean Eigenmann <7621705+decanus@users.noreply.github.com>
 Dean Prichard <dean.prichard@gmail.com>
 Deepak Jois <deepak.jois@gmail.com>
-Deepak S <deepakspavoodath@gmail.com>
 Denis Bernard <db047h@gmail.com>
 Denis Brandolini <denis.brandolini@gmail.com>
 Denis Isaev <idenx@yandex.com>
@@ -701,10 +676,8 @@ Dhiru Kholia <dhiru.kholia@gmail.com>
 Dhruvdutt Jadhav <dhruvdutt.jadhav@gmail.com>
 Di Xiao <dixiao@google.com>
 Didier Spezia <didier.06@gmail.com>
-Diego Medina <fmpwizard@gmail.com>
 Diego Siqueira <diego9889@gmail.com>
 Dieter Plaetinck <dieter@raintank.io>
-Dilyn Corner <dilyn.corner@gmail.com>
 Dimitri Sokolyuk <sokolyuk@gmail.com>
 Dimitri Tcaciuc <dtcaciuc@gmail.com>
 Dina Garmash <dgrmsh@gmail.com>
@@ -741,7 +714,6 @@ Doug Fawley <dfawley@google.com>
 Douglas Danger Manley <doug.manley@gmail.com>
 Drew Flower <drewvanstone@gmail.com>
 Drew Hintz <adhintz@google.com>
-Drew Richardson <drewrichardson@gmail.com>
 Duco van Amstel <duco.vanamstel@gmail.com>
 Duncan Holm <mail@frou.org>
 Dustin Carlino <dcarlino@google.com>
@@ -763,7 +735,6 @@ Egon Elbre <egonelbre@gmail.com>
 Ehren Kret <ehren.kret@gmail.com>
 Eitan Adler <lists@eitanadler.com>
 Eivind Uggedal <eivind@uggedal.com>
-El Mostafa Idrassi <el.mostafa.idrassi@gmail.com>
 Elbert Fliek <efliek@gmail.com>
 Eldar Rakhimberdin <ibeono@gmail.com>
 Elena Grahovac <elena@grahovac.me>
@@ -771,7 +742,6 @@ Eli Bendersky <eliben@google.com>
 Elias Naur <mail@eliasnaur.com> <elias.naur@gmail.com>
 Elliot Morrison-Reed <elliotmr@gmail.com>
 Ellison Leão <ellisonleao@gmail.com>
-Elvina Yakubova <elvinayakubova@gmail.com>
 Emerson Lin <linyintor@gmail.com>
 Emil Bektimirov <lefelys@gmail.com>
 Emil Hessman <emil@hessman.se>
@@ -797,7 +767,6 @@ Eric Rescorla <ekr@rtfm.com>
 Eric Roshan-Eisner <eric.d.eisner@gmail.com>
 Eric Rutherford <erutherford@gmail.com>
 Eric Rykwalder <e.rykwalder@gmail.com>
-Eric Wang <wangchaogo1990@gmail.com>
 Erick Tryzelaar <etryzelaar@google.com>
 Erik Aigner <aigner.erik@gmail.com>
 Erik Dubbelboer <erik@dubbelboer.com>
@@ -809,7 +778,6 @@ Ernest Chiang <ernest_chiang@htc.com>
 Erwin Oegema <blablaechthema@hotmail.com>
 Esko Luontola <esko.luontola@gmail.com>
 Ethan Burns <eaburns@google.com>
-Ethan Hur <ethan0311@gmail.com>
 Ethan Miller <eamiller@us.ibm.com>
 Euan Kemp <euank@euank.com>
 Eugene Formanenko <mo4islona@gmail.com>
@@ -850,7 +818,6 @@ Felix Cornelius <9767036+fcornelius@users.noreply.github.com>
 Felix Geisendörfer <haimuiba@gmail.com>
 Felix Kollmann <fk@konsorten.de>
 Ferenc Szabo <frncmx@gmail.com>
-Fernandez Ludovic <lfernandez.dev@gmail.com>
 Filip Gruszczyński <gruszczy@gmail.com>
 Filip Haglund <drathier@users.noreply.github.com>
 Filip Stanis <fstanis@google.com>
@@ -891,7 +858,6 @@ Gabriel Nelle <tehsphinx@web.de>
 Gabriel Nicolas Avellaneda <avellaneda.gabriel@gmail.com>
 Gabriel Rosenhouse <rosenhouse@gmail.com>
 Gabriel Russell <gabriel.russell@gmail.com>
-Gabriel Vasile <gabriel.vasile0793@gmail.com>
 Gareth Paul Jones <gpj@foursquare.com>
 Garret Kelly <gdk@google.com>
 Garrick Evans <garrick@google.com>
@@ -925,8 +891,6 @@ Gianguido Sora` <g.sora4@gmail.com>
 Gideon Jan-Wessel Redelinghuys <gjredelinghuys@gmail.com>
 Giles Lean <giles.lean@pobox.com>
 Giovanni Bajo <rasky@develer.com>
-GitHub User @180909 (70465953) <734461790@qq.com>
-GitHub User @6543 (24977596) <6543@obermui.de>
 GitHub User @aca (50316549) <acadx0@gmail.com>
 GitHub User @ajnirp (1688456) <ajnirp@users.noreply.github.com>
 GitHub User @ajz01 (4744634) <ajzdenek@gmail.com>
@@ -940,12 +904,10 @@ GitHub User @bontequero (2674999) <bontequero@gmail.com>
 GitHub User @cch123 (384546) <buaa.cch@gmail.com>
 GitHub User @chainhelen (7046329) <chainhelen@gmail.com>
 GitHub User @chanxuehong (3416908) <chanxuehong@gmail.com>
-GitHub User @Cluas (10056928) <Cluas@live.cn>
 GitHub User @cncal (23520240) <flycalvin@qq.com>
 GitHub User @DQNEO (188741) <dqneoo@gmail.com>
 GitHub User @Dreamacro (8615343) <chuainian@gmail.com>
 GitHub User @dupoxy (1143957) <dupoxy@users.noreply.github.com>
-GitHub User @EndlessCheng (7086966) <loli.con@qq.com>
 GitHub User @erifan (31343225) <eric.fang@arm.com>
 GitHub User @esell (9735165) <eujon.sellers@gmail.com>
 GitHub User @fatedier (7346661) <fatedier@gmail.com>
@@ -954,15 +916,12 @@ GitHub User @geedchin (11672310) <geedchin@gmail.com>
 GitHub User @GrigoriyMikhalkin (3637857) <grigoriymikhalkin@gmail.com>
 GitHub User @hengwu0 (41297446) <41297446+hengwu0@users.noreply.github.com>
 GitHub User @hitzhangjie (3725760) <hit.zhangjie@gmail.com>
-GitHub User @hqpko (13887251) <whaibin01@hotmail.com>
 GitHub User @itchyny (375258) <itchyny@hatena.ne.jp>
 GitHub User @jinmiaoluo (39730824) <jinmiaoluo@icloud.com>
 GitHub User @jopbrown (6345470) <msshane2008@gmail.com>
 GitHub User @kazyshr (30496953) <kazyshr0301@gmail.com>
 GitHub User @kc1212 (1093806) <kc1212@users.noreply.github.com>
-GitHub User @komisan19 (18901496) <komiyama6219@gmail.com>
 GitHub User @Kropekk (13366453) <kamilkropiewnicki@gmail.com>
-GitHub User @lhl2617 (33488131) <l.h.lee2617@gmail.com>
 GitHub User @linguohua (3434367) <lghchinaidea@gmail.com>
 GitHub User @LotusFenn (13775899) <fenn.lotus@gmail.com>
 GitHub User @ly303550688 (11519839) <yang.liu636@gmail.com>
@@ -977,14 +936,10 @@ GitHub User @OlgaVlPetrova (44112727) <OVPpetrova@gmail.com>
 GitHub User @pityonline (438222) <pityonline@gmail.com>
 GitHub User @po3rin (29445112) <abctail30@gmail.com>
 GitHub User @pokutuna (57545) <popopopopokutuna@gmail.com>
-GitHub User @povsister (11040951) <pov@mahou-shoujo.moe>
 GitHub User @pytimer (17105586) <lixin20101023@gmail.com>
-GitHub User @qcrao (7698088) <qcrao91@gmail.com>
 GitHub User @ramenjuniti (32011829) <ramenjuniti@gmail.com>
 GitHub User @saitarunreddy (21041941) <saitarunreddypalla@gmail.com>
-GitHub User @SataQiu (9354727) <shidaqiu2018@gmail.com>
 GitHub User @shogo-ma (9860598) <Choroma194@gmail.com>
-GitHub User @sivchari (55221074) <shibuuuu5@gmail.com>
 GitHub User @skanehira (7888591) <sho19921005@gmail.com>
 GitHub User @soolaugust (10558124) <soolaugust@gmail.com>
 GitHub User @surechen (7249331) <surechen17@gmail.com>
@@ -992,12 +947,9 @@ GitHub User @tatsumack (4510569) <tatsu.mack@gmail.com>
 GitHub User @tell-k (26263) <ffk2005@gmail.com>
 GitHub User @tennashi (10219626) <tennashio@gmail.com>
 GitHub User @uhei (2116845) <uhei@users.noreply.github.com>
-GitHub User @uji (49834542) <ujiprog@gmail.com>
-GitHub User @unbyte (5772358) <i@shangyes.net>
 GitHub User @uropek (39370426) <uropek@gmail.com>
 GitHub User @utkarsh-extc (53217283) <utkarsh.extc@gmail.com>
 GitHub User @witchard (4994659) <witchard@hotmail.co.uk>
-GitHub User @wolf1996 (5901874) <ksgiv37@gmail.com>
 GitHub User @yah01 (12216890) <kagaminehuan@gmail.com>
 GitHub User @yuanhh (1298735) <yuan415030@gmail.com>
 GitHub User @zikaeroh (48577114) <zikaeroh@gmail.com>
@@ -1010,7 +962,6 @@ Glenn Brown <glennb@google.com>
 Glenn Lewis <gmlewis@google.com>
 Gordon Klaus <gordon.klaus@gmail.com>
 Gordon Tyler <gordon@doxxx.net>
-Grace Han <hgrace503@gmail.com>
 Graham King <graham4king@gmail.com>
 Graham Miller <graham.miller@gmail.com>
 Grant Griffiths <ggp493@gmail.com>
@@ -1026,12 +977,10 @@ Guilherme Caruso <gui.martinscaruso@gmail.com>
 Guilherme Garnier <guilherme.garnier@gmail.com>
 Guilherme Goncalves <guilhermeaugustosg@gmail.com>
 Guilherme Rezende <guilhermebr@gmail.com>
-Guilherme Souza <32180229+gqgs@users.noreply.github.com>
 Guillaume J. Charmes <guillaume@charmes.net>
 Guillaume Sottas <guillaumesottas@gmail.com>
 Günther Noack <gnoack@google.com>
 Guobiao Mei <meiguobiao@gmail.com>
-Guodong Li <guodongli@google.com>
 Guoliang Wang <iamwgliang@gmail.com>
 Gustav Paul <gustav.paul@gmail.com>
 Gustav Westling <gustav@westling.xyz>
@@ -1046,7 +995,6 @@ HAMANO Tsukasa <hamano@osstech.co.jp>
 Han-Wen Nienhuys <hanwen@google.com>
 Hang Qian <hangqian90@gmail.com>
 Hanjun Kim <hallazzang@gmail.com>
-Hanlin He <hanling.he@gmail.com>
 Hanlin Shi <shihanlin9@gmail.com>
 Haoran Luo <haoran.luo@chaitin.com>
 Haosdent Huang <haosdent@gmail.com>
@@ -1078,19 +1026,18 @@ Herbie Ong <herbie@google.com>
 Heschi Kreinick <heschi@google.com>
 Hidetatsu Yaginuma <ygnmhdtt@gmail.com>
 Hilko Bengen <bengen@hilluzination.de>
-Himanshu Kishna Srivastava <28himanshu@gmail.com>
 Hiroaki Nakamura <hnakamur@gmail.com>
 Hiromichi Ema <ema.hiro@gmail.com>
 Hironao OTSUBO <motemen@gmail.com>
 Hiroshi Ioka <hirochachacha@gmail.com>
 Hitoshi Mitake <mitake.hitoshi@gmail.com>
 Holden Huang <ttyh061@gmail.com>
+Songlin Jiang <hollowman@hollowman.ml>
 Hong Ruiqi <hongruiqi@gmail.com>
 Hongfei Tan <feilengcui008@gmail.com>
 Horacio Duran <horacio.duran@gmail.com>
 Horst Rutter <hhrutter@gmail.com>
 Hossein Sheikh Attar <hattar@google.com>
-Hossein Zolfi <hossein.zolfi@gmail.com>
 Howard Zhang <howard.zhang@arm.com>
 Hsin Tsao <tsao@google.com>
 Hsin-Ho Yeh <yhh92u@gmail.com>
@@ -1107,14 +1054,11 @@ Ian Haken <ihaken@netflix.com>
 Ian Kent <iankent85@gmail.com>
 Ian Lance Taylor <iant@golang.org>
 Ian Leue <ian@appboy.com>
-Ian Mckay <iann0036@gmail.com>
 Ian Tay <iantay@google.com>
-Ian Woolf <btw515wolf2@gmail.com>
 Ian Zapolsky <ianzapolsky@gmail.com>
 Ibrahim AshShohail <ibra.sho@gmail.com>
 Icarus Sparry <golang@icarus.freeuk.com>
 Iccha Sethi <icchasethi@gmail.com>
-Ichinose Shogo <shogo82148@gmail.com>
 Idora Shinatose <idora.shinatose@gmail.com>
 Ignacio Hagopian <jsign.uy@gmail.com>
 Igor Bernstein <igorbernstein@google.com>
@@ -1124,7 +1068,6 @@ Igor Vashyst <ivashyst@gmail.com>
 Igor Zhilianin <igor.zhilianin@gmail.com>
 Ikko Ashimine <eltociear@gmail.com>
 Illya Yalovyy <yalovoy@gmail.com>
-Ilya Chukov <56119080+Elias506@users.noreply.github.com>
 Ilya Sinelnikov <sidhmangh@gmail.com>
 Ilya Tocar <ilya.tocar@intel.com>
 INADA Naoki <songofacandy@gmail.com>
@@ -1179,7 +1122,6 @@ James Cowgill <James.Cowgill@imgtec.com>
 James Craig Burley <james-github@burleyarch.com>
 James David Chalfant <james.chalfant@gmail.com>
 James Eady <jmeady@google.com>
-James Fennell <jpfennell@google.com>
 James Fysh <james.fysh@gmail.com>
 James Gray <james@james4k.com>
 James Hartig <fastest963@gmail.com>
@@ -1236,7 +1178,6 @@ Jason Wangsadinata <jwangsadinata@gmail.com>
 Javier Kohen <jkohen@google.com>
 Javier Revillas <jrevillas@massivedynamic.io>
 Javier Segura <javism@gmail.com>
-Jay Chen <chenjie@chenjie.info>
 Jay Conrod <jayconrod@google.com>
 Jay Lee <BusyJayLee@gmail.com>
 Jay Taylor <outtatime@gmail.com>
@@ -1259,7 +1200,6 @@ Jeff Johnson <jrjohnson@google.com>
 Jeff R. Allen <jra@nella.org> <jeff.allen@gmail.com>
 Jeff Sickel <jas@corpus-callosum.com>
 Jeff Wendling <jeff@spacemonkey.com>
-Jeff Widman <jeff@jeffwidman.com>
 Jeffrey H <jeffreyh192@gmail.com>
 Jelte Fennema <github-tech@jeltef.nl>
 Jens Frederich <jfrederich@gmail.com>
@@ -1270,7 +1210,6 @@ Jeremy Faller <jeremy@golang.org>
 Jeremy Jackins <jeremyjackins@gmail.com>
 Jeremy Jay <jeremy@pbnjay.com>
 Jeremy Schlatter <jeremy.schlatter@gmail.com>
-Jero Bado <tokidokitalkyou@gmail.com>
 Jeroen Bobbeldijk <jerbob92@gmail.com>
 Jeroen Simonetti <jeroen@simonetti.nl>
 Jérôme Doucet <jerdct@gmail.com>
@@ -1312,8 +1251,6 @@ Joe Richey <joerichey@google.com>
 Joe Shaw <joe@joeshaw.org>
 Joe Sylve <joe.sylve@gmail.com>
 Joe Tsai <joetsai@digital-static.net>
-Joel Courtney <euphemize@gmail.com>
-Joel Ferrier <joelferrier@google.com>
 Joel Sing <joel@sing.id.au> <jsing@google.com>
 Joël Stemmer <jstemmer@google.com>
 Joel Stemmer <stemmertech@gmail.com>
@@ -1323,9 +1260,7 @@ Johan Euphrosine <proppy@google.com>
 Johan Jansson <johan.jansson@iki.fi>
 Johan Knutzen <johan@senri.se>
 Johan Sageryd <j@1616.se>
-Johannes Huning <johannes.huning@gmail.com>
 John Asmuth <jasmuth@gmail.com>
-John Bampton <jbampton@gmail.com>
 John Beisley <huin@google.com>
 John C Barstow <jbowtie@amathaine.com>
 John DeNero <denero@google.com>
@@ -1334,7 +1269,6 @@ John Gibb <johngibb@gmail.com>
 John Gilik <john@jgilik.com>
 John Graham-Cumming <jgc@jgc.org> <jgrahamc@gmail.com>
 John Howard Palevich <jack.palevich@gmail.com>
-John Jago <johnjago@protonmail.com>
 John Jeffery <jjeffery@sp.com.au>
 John Jenkins <twodopeshaggy@gmail.com>
 John Leidegren <john.leidegren@gmail.com>
@@ -1386,7 +1320,6 @@ Josa Gesell <josa@gesell.me>
 Jose Luis Vázquez González <josvazg@gmail.com>
 Joseph Bonneau <jcb@google.com>
 Joseph Holsten <joseph@josephholsten.com>
-Joseph Morag <sefim96@gmail.com>
 Josh Baum <joshbaum@google.com>
 Josh Bleecher Snyder <josharian@gmail.com>
 Josh Chorlton <jchorlton@gmail.com>
@@ -1394,14 +1327,12 @@ Josh Deprez <josh.deprez@gmail.com>
 Josh Goebel <dreamer3@gmail.com>
 Josh Hoak <jhoak@google.com>
 Josh Holland <jrh@joshh.co.uk>
-Josh Rickmar <jrick@companyzero.com>
 Josh Roppo <joshroppo@gmail.com>
 Josh Varga <josh.varga@gmail.com>
 Joshua Bezaleel Abednego <joshua.bezaleel@gmail.com>
 Joshua Boelter <joshua.boelter@intel.com>
 Joshua Chase <jcjoshuachase@gmail.com>
 Joshua Crowgey <jcrowgey@uw.edu>
-Joshua Harshman <joshgreyhat@gmail.com>
 Joshua M. Clulow <josh.clulow@joyent.com>
 Joshua Rubin <joshua@rubixconsulting.com>
 Josselin Costanzi <josselin@costanzi.fr>
@@ -1422,7 +1353,6 @@ Julie Qiu <julie@golang.org>
 Julien Kauffmann <julien.kauffmann@freelan.org>
 Julien Salleyron <julien.salleyron@gmail.com>
 Julien Schmidt <google@julienschmidt.com>
-Julien Tant <julien@craftyx.fr>
 Julio Montes <julio.montes@intel.com>
 Jun Zhang <jim.zoumo@gmail.com>
 Junchen Li <junchen.li@arm.com>
@@ -1489,12 +1419,10 @@ Kenta Mori <zoncoen@gmail.com>
 Kerollos Magdy <kerolloz@yahoo.com>
 Ketan Parmar <ketanbparmar@gmail.com>
 Kevan Swanberg <kevswanberg@gmail.com>
-Kevin Albertson <kevin.albertson@mongodb.com>
 Kevin Ballard <kevin@sb.org>
 Kevin Burke <kev@inburke.com>
 Kévin Dunglas <dunglas@gmail.com>
 Kevin Gillette <extemporalgenome@gmail.com>
-Kevin Herro <kevin109104@gmail.com>
 Kevin Kirsche <kev.kirsche@gmail.com>
 Kevin Klues <klueska@gmail.com> <klueska@google.com>
 Kevin Malachowski <chowski@google.com>
@@ -1529,7 +1457,6 @@ Koya IWAMURA <kiwamura0314@gmail.com>
 Kris Kwiatkowski <kris@cloudflare.com>
 Kris Nova <kris@nivenly.com>
 Kris Rousey <krousey@google.com>
-Krishna Birla <krishnabirla16@gmail.com>
 Kristopher Watts <traetox@gmail.com>
 Krzysztof Dąbrowski <krzysdabro@live.com>
 Kshitij Saraogi <kshitijsaraogi@gmail.com>
@@ -1553,7 +1480,6 @@ Lajos Papp <lalyos@yahoo.com>
 Lakshay Garg <lakshay.garg.1996@gmail.com>
 Lann Martin <lannm@google.com>
 Lanre Adelowo <yo@lanre.wtf>
-Lapo Luchini <lapo@lapo.it>
 Larry Clapp <larry@theclapp.org>
 Larry Hosken <lahosken@golang.org>
 Lars Jeppesen <jeppesen.lars@gmail.com>
@@ -1570,7 +1496,6 @@ Leigh McCulloch <leighmcc@gmail.com>
 Leo Antunes <leo@costela.net>
 Leo Rudberg <ljr@google.com>
 Leon Klingele <git@leonklingele.de>
-Leonard Wang <wangdeyu0907@gmail.com>
 Leonardo Comelli <leonardo.comelli@gmail.com>
 Leonel Quinteros <leonel.quinteros@gmail.com>
 Lev Shamardin <shamardin@gmail.com>
@@ -1581,9 +1506,7 @@ Lily Chung <lilithkchung@gmail.com>
 Lingchao Xin <douglarek@gmail.com>
 Lion Yang <lion@aosc.xyz>
 Liz Rice <liz@lizrice.com>
-Lize Cai <lizzzcai1@gmail.com>
 Lloyd Dewolf <foolswisdom@gmail.com>
-Lluís Batlle i Rossell <viric@viric.name>
 Lorenz Bauer <lmb@cloudflare.com>
 Lorenz Brun <lorenz@brun.one>
 Lorenz Nickel <mail@lorenznickel.de>
@@ -1608,7 +1531,6 @@ Lukasz Milewski <lmmilewski@gmail.com>
 Luke Champine <luke.champine@gmail.com>
 Luke Curley <qpingu@gmail.com>
 Luke Granger-Brown <git@lukegb.com>
-Luke Shumaker <lukeshu@datawire.io>
 Luke Young <bored-engineer@users.noreply.github.com>
 Luna Duclos <luna.duclos@palmstonegames.com>
 Luuk van Dijk <lvd@golang.org> <lvd@google.com>
@@ -1628,7 +1550,6 @@ Mal Curtis <mal@mal.co.nz>
 Manfred Touron <m@42.am>
 Manigandan Dharmalingam <manigandan.jeff@gmail.com>
 Manish Goregaokar <manishsmail@gmail.com>
-Manlio Perillo <manlio.perillo@gmail.com>
 Manoj Dayaram <platform-dev@moovweb.com> <manoj.dayaram@moovweb.com>
 Mansour Rahimi <rahimi.mnr@gmail.com>
 Manu Garg <manugarg@google.com>
@@ -1725,8 +1646,6 @@ Matt Joiner <anacrolix@gmail.com>
 Matt Jones <mrjones@google.com>
 Matt Juran <thepciet@gmail.com>
 Matt Layher <mdlayher@gmail.com>
-Matt Masurka <masurka@google.com>
-Matt Pearring <broskies@google.com>
 Matt Reiferson <mreiferson@gmail.com>
 Matt Robenolt <matt@ydekproductions.com>
 Matt Strong <mstrong1341@gmail.com>
@@ -1740,12 +1659,9 @@ Matthew Denton <mdenton@skyportsystems.com>
 Matthew Holt <Matthew.Holt+git@gmail.com>
 Matthew Horsnell <matthew.horsnell@gmail.com>
 Matthew Waters <mwwaters@gmail.com>
-Matthias Frei <matthias.frei@inf.ethz.ch>
 Matthieu Hauglustaine <matt.hauglustaine@gmail.com>
 Matthieu Olivier <olivier.matthieu@gmail.com>
 Matthijs Kooijman <matthijs@stdin.nl>
-Mattias Appelgren <mattias@ppelgren.se>
-Mauricio Alvarado <mauricio.alvarado@leftfieldlabs.com>
 Max Drosdo.www <g1ran1q@gmail.com>
 Max Riveiro <kavu13@gmail.com>
 Max Schmitt <max@schmitt.mx>
@@ -1761,11 +1677,9 @@ Máximo Cuadros Ortiz <mcuadros@gmail.com>
 Maxwell Krohn <themax@gmail.com>
 Maya Rashish <maya@NetBSD.org>
 Mayank Kumar <krmayankk@gmail.com>
-Mehrad Sadeghi <2012.linkinpark@gmail.com>
 Meir Fischer <meirfischer@gmail.com>
 Meng Zhuo <mengzhuo1203@gmail.com> <mzh@golangcn.org>
 Mhd Sulhan <m.shulhan@gmail.com>
-Mia Zhu <CrystalZhu1025getu@gmail.com>
 Micah Stetson <micah.stetson@gmail.com>
 Michael Anthony Knyszek <mknyszek@google.com>
 Michael Brandenburg <mbrandenburg@bolste.com>
@@ -1816,10 +1730,8 @@ Michal Franc <lam.michal.franc@gmail.com>
 Michał Łowicki <mlowicki@gmail.com>
 Michal Pristas <michal.pristas@gmail.com>
 Michal Rostecki <mrostecki@suse.de>
-Michal Stokluska <mstoklus@redhat.com>
 Michalis Kargakis <michaliskargakis@gmail.com>
 Michel Lespinasse <walken@google.com>
-Michel Levieux <mlevieux42@gmail.com>
 Michele Di Pede <michele.di.pede@gmail.com>
 Mickael Kerjean <mickael.kerjean@gmail.com>
 Mickey Reiss <mickeyreiss@gmail.com>
@@ -1878,9 +1790,7 @@ Muir Manders <muir@mnd.rs>
 Mukesh Sharma <sharma.mukesh439@gmail.com>
 Mura Li <mura_li@castech.com.tw>
 Mykhailo Lesyk <mikhail@lesyk.org>
-Nahum Shalman <nahamu@gmail.com>
 Naman Aggarwal <aggarwal.nam@gmail.com>
-Naman Gera <namangera15@gmail.com>
 Nan Deng <monnand@gmail.com>
 Nao Yonashiro <owan.orisano@gmail.com>
 Naoki Kanatani <k12naoki@gmail.com>
@@ -1908,7 +1818,6 @@ Neven Sajko <nsajko@gmail.com>
 Nevins Bartolomeo <nevins.bartolomeo@gmail.com>
 Niall Sheridan <nsheridan@gmail.com>
 Nic Day <nic.day@me.com>
-Nicholas Asimov <nicholas@asimov.me>
 Nicholas Katsaros <nick@nickkatsaros.com>
 Nicholas Maniscalco <nicholas@maniscalco.com>
 Nicholas Ng <nickng@nickng.io>
@@ -1938,7 +1847,6 @@ Nik Nyby <nnyby@columbia.edu>
 Nikhil Benesch <nikhil.benesch@gmail.com>
 Nikita Gillmann <nikita@n0.is> <ng0@n0.is>
 Nikita Kryuchkov <nkryuchkov10@gmail.com>
-Nikita Melekhin <nimelehin@gmail.com>
 Nikita Vanyasin <nikita.vanyasin@gmail.com>
 Niklas Schnelle <niklas.schnelle@gmail.com>
 Niko Dziemba <niko@dziemba.com>
@@ -1950,7 +1858,6 @@ Niranjan Godbole <niranjan8192@gmail.com>
 Nishanth Shanmugham <nishanth.gerrard@gmail.com>
 Noah Campbell <noahcampbell@gmail.com>
 Noah Goldman <noahg34@gmail.com>
-Noah Santschi-Cooney <noah@santschi-cooney.ch>
 Noble Johnson <noblepoly@gmail.com>
 Nodir Turakulov <nodir@google.com>
 Noel Georgi <git@frezbo.com>
@@ -1987,7 +1894,6 @@ Pablo Rozas Larraondo <pablo.larraondo@anu.edu.au>
 Pablo Santiago Blum de Aguiar <scorphus@gmail.com>
 Padraig Kitterick <padraigkitterick@gmail.com>
 Pallat Anchaleechamaikorn <yod.pallat@gmail.com>
-Pan Chenglong <1004907659@qq.com>
 Panos Georgiadis <pgeorgiadis@suse.de>
 Pantelis Sampaziotis <psampaz@gmail.com>
 Paolo Giarrusso <p.giarrusso@gmail.com>
@@ -2041,7 +1947,6 @@ Paulo Casaretto <pcasaretto@gmail.com>
 Paulo Flabiano Smorigo <pfsmorigo@linux.vnet.ibm.com>
 Paulo Gomes <paulo.gomes.uk@gmail.com>
 Pavel Paulau <pavel.paulau@gmail.com>
-Pavel Watson <watsonpavel@gmail.com>
 Pavel Zinovkin <pavel.zinovkin@gmail.com>
 Pavlo Sumkin <ymkins@gmail.com>
 Pawel Knap <pawelknap88@gmail.com>
@@ -2049,8 +1954,6 @@ Pawel Szczur <filemon@google.com>
 Paweł Szulik <pawel.szulik@intel.com>
 Pei Xian Chee <luciolas1991@gmail.com>
 Pei-Ming Wu <p408865@gmail.com>
-Pen Tree <appletree2479@outlook.com>
-Peng Gao <peng.gao.dut@gmail.com>
 Percy Wegmann <ox.to.a.cart@gmail.com>
 Perry Abbott <perry.j.abbott@gmail.com>
 Petar Dambovaliev <petar.atanasov.1987@gmail.com>
@@ -2089,7 +1992,6 @@ Philip Brown <phil@bolthole.com>
 Philip Hofer <phofer@umich.edu>
 Philip K. Warren <pkwarren@gmail.com>
 Philip Nelson <me@pnelson.ca>
-Philipp Sauter <sauterp@protonmail.com>
 Philipp Stephani <phst@google.com>
 Phillip Campbell <15082+phillc@users.noreply.github.com>
 Pierre Carru <pierre.carru@eshard.com>
@@ -2105,7 +2007,6 @@ Poh Zi How <poh.zihow@gmail.com>
 Polina Osadcha <polliosa@google.com>
 Pontus Leitzler <leitzler@gmail.com>
 Povilas Versockas <p.versockas@gmail.com>
-Prajwal Koirala <16564273+Prajwal-Koirala@users.noreply.github.com>
 Prasanga Siripala <pj@pjebs.com.au>
 Prasanna Swaminathan <prasanna@mediamath.com>
 Prashant Agrawal <prashant.a.vjti@gmail.com>
@@ -2126,13 +2027,11 @@ Quim Muntal <quimmuntal@gmail.com>
 Quinn Slack <sqs@sourcegraph.com>
 Quinten Yearsley <qyearsley@chromium.org>
 Quoc-Viet Nguyen <afelion@gmail.com>
-Rabin Gaire <rabingaire20@gmail.com>
 Radek Simko <radek.simko@gmail.com>
 Radek Sohlich <sohlich@gmail.com>
 Radu Berinde <radu@cockroachlabs.com>
 Rafal Jeczalik <rjeczalik@gmail.com>
 Raghavendra Nagaraj <jamdagni86@gmail.com>
-Rahul Bajaj <rahulrb0509@gmail.com>
 Rahul Chaudhry <rahulchaudhry@chromium.org>
 Rahul Wadhwani <rahulwadhwani21@gmail.com>
 Raif S. Naffah <go@naffah-raif.name>
@@ -2142,14 +2041,12 @@ Rajender Reddy Kompally <rajenderreddykompally@gmail.com>
 Ralph Corderoy <ralph@inputplus.co.uk>
 Ramazan AYYILDIZ <rayyildiz@gmail.com>
 Ramesh Dharan <dharan@google.com>
-Randy Reddig <randy@alta.software>
 Raph Levien <raph@google.com>
 Raphael Geronimi <raphael.geronimi@gmail.com>
 Raul Silvera <rsilvera@google.com>
 Ravil Bikbulatov <weeellz12@gmail.com>
 RaviTeja Pothana <ravi.tezu@gmail.com>
 Ray Tung <rtung@thoughtworks.com>
-Ray Wu <ray@liftoff.io>
 Raymond Kazlauskas <raima220@gmail.com>
 Rebecca Stambler <rstambler@golang.org>
 Reilly Watson <reillywatson@gmail.com>
@@ -2169,7 +2066,6 @@ Richard Eric Gavaletz <gavaletz@gmail.com>
 Richard Gibson <richard.gibson@gmail.com>
 Richard Miller <miller.research@gmail.com>
 Richard Musiol <mail@richard-musiol.de> <neelance@gmail.com>
-Richard Pickering <richard.pickering@hotmail.co.uk>
 Richard Ulmer <codesoap@mailbox.org>
 Richard Wilkes <wilkes@me.com>
 Rick Arnold <rickarnoldjr@gmail.com>
@@ -2228,7 +2124,6 @@ Rowan Worth <sqweek@gmail.com>
 Rudi Kramer <rudi.kramer@gmail.com>
 Rui Ueyama <ruiu@google.com>
 Ruixin Bao <ruixin.bao@ibm.com>
-Ruslan Andreev <ruslan.andreev@huawei.com>
 Ruslan Nigmatullin <elessar@dropbox.com>
 Russ Cox <rsc@golang.org>
 Russell Haering <russellhaering@gmail.com>
@@ -2246,7 +2141,6 @@ Ryan Seys <ryan@ryanseys.com>
 Ryan Slade <ryanslade@gmail.com>
 Ryan Zhang <ryan.zhang@docker.com>
 Ryoichi KATO <ryo1kato@gmail.com>
-Ryoya Sekino <ryoyasekino1993@gmail.com>
 Ryuji Iwata <qt.luigi@gmail.com>
 Ryuma Yoshida <ryuma.y1117@gmail.com>
 Ryuzo Yamamoto <ryuzo.yamamoto@gmail.com>
@@ -2282,10 +2176,8 @@ Sardorbek Pulatov <sardorbek.pulatov@outlook.com>
 Sascha Brawer <sascha@brawer.ch>
 Sasha Lionheart <lionhearts@google.com>
 Sasha Sobol <sasha@scaledinference.com>
-Satoru Kitaguchi <rule.the.fate.myfirststory@gmail.com>
 Scott Barron <scott.barron@github.com>
 Scott Bell <scott@sctsm.com>
-Scott Cotton <scott@mindowl.com>
 Scott Crunkleton <crunk1@gmail.com>
 Scott Ferguson <scottwferg@gmail.com>
 Scott Lawrence <bytbox@gmail.com>
@@ -2299,7 +2191,6 @@ Sean Chittenden <seanc@joyent.com>
 Sean Christopherson <sean.j.christopherson@intel.com>
 Sean Dolphin <Sean.Dolphin@kpcompass.com>
 Sean Harger <sharger@google.com>
-Sean Harrington <sean.harrington@leftfieldlabs.com>
 Sean Hildebrand <seanwhildebrand@gmail.com>
 Sean Liao <seankhliao@gmail.com>
 Sean Rees <sean@erifax.org>
@@ -2321,7 +2212,6 @@ Sergey Dobrodey <sergey.dobrodey@synesis.ru>
 Sergey Frolov <sfrolov@google.com>
 Sergey Glushchenko <gsserge@gmail.com>
 Sergey Ivanov <ser1325@gmail.com>
-Sergey Kacheev <S.Kacheev@gmail.com>
 Sergey Lukjanov <me@slukjanov.name>
 Sergey Mishin <sergeymishine@gmail.com>
 Sergey Mudrik <sergey.mudrik@gmail.com>
@@ -2333,7 +2223,6 @@ Serhat Giydiren <serhatgiydiren@gmail.com>
 Serhii Aheienko <serhii.aheienko@gmail.com>
 Seth Hoenig <seth.a.hoenig@gmail.com>
 Seth Vargo <sethvargo@gmail.com>
-Shaba Abhiram <shabarivas.abhiram@gmail.com>
 Shahar Kohanim <skohanim@gmail.com>
 Shailesh Suryawanshi <ss.shailesh28@gmail.com>
 Shamil Garatuev <garatuev@gmail.com>
@@ -2361,13 +2250,9 @@ Shivakumar GN <shivakumar.gn@gmail.com>
 Shivani Singhal <shivani.singhal2804@gmail.com>
 Shivansh Rai <shivansh@freebsd.org>
 Shivashis Padhi <shivashispadhi@gmail.com>
-Shoshin Nikita <shoshin_nikita@fastmail.com>
-Shota Sugiura <s.shota.710.3506@gmail.com>
 Shubham Sharma <shubham.sha12@gmail.com>
-Shuhei Takahashi <nya@chromium.org>
 Shun Fan <sfan@google.com>
 Silvan Jegen <s.jegen@gmail.com>
-Simão Gomes Viana <simaogmv@gmail.com>
 Simarpreet Singh <simar@linux.com>
 Simon Drake <simondrake1990@gmail.com>
 Simon Ferquel <simon.ferquel@docker.com>
@@ -2382,16 +2267,13 @@ Sina Siadat <siadat@gmail.com>
 Sjoerd Siebinga <sjoerd.siebinga@gmail.com>
 Sokolov Yura <funny.falcon@gmail.com>
 Song Gao <song@gao.io>
-Song Lim <songlim327@gmail.com>
 Songjiayang <songjiayang1@gmail.com>
-Songlin Jiang <hollowman@hollowman.ml>
 Soojin Nam <jsunam@gmail.com>
 Søren L. Hansen <soren@linux2go.dk>
 Sparrow Li <liyuancylx@gmail.com>
 Spencer Kocot <spencerkocot@gmail.com>
 Spencer Nelson <s@spenczar.com>
 Spencer Tung <spencertung@google.com>
-Spenser Black <spenserblack01@gmail.com>
 Spring Mc <heresy.mc@gmail.com>
 Srdjan Petrovic <spetrovic@google.com>
 Sridhar Venkatakrishnan <sridhar@laddoo.net>
@@ -2442,7 +2324,6 @@ Suyash <dextrous93@gmail.com>
 Suzy Mueller <suzmue@golang.org>
 Sven Almgren <sven@tras.se>
 Sven Blumenstein <svbl@google.com>
-Sven Lee <lee1300394324@gmail.com>
 Sven Taute <sven.taute@gmail.com>
 Sylvain Zimmer <sylvain@sylvainzimmer.com>
 Syohei YOSHIDA <syohex@gmail.com>
@@ -2525,14 +2406,12 @@ Tiwei Bie <tiwei.btw@antgroup.com>
 Tobias Assarsson <tobias.assarsson@gmail.com>
 Tobias Columbus <tobias.columbus@gmail.com> <tobias.columbus@googlemail.com>
 Tobias Klauser <tklauser@distanz.ch>
-Tobias Kohlbau <tobias@kohlbau.de>
 Toby Burress <kurin@google.com>
 Todd Kulesza <tkulesza@google.com>
 Todd Neal <todd@tneal.org>
 Todd Wang <toddwang@gmail.com>
 Tom Anthony <git@tomanthony.co.uk>
 Tom Bergan <tombergan@google.com>
-Tom Freudenberg <tom.freudenberg@4commerce.de>
 Tom Heng <zhm20070928@gmail.com>
 Tom Lanyon <tomlanyon@google.com>
 Tom Levy <tomlevy93@gmail.com>
@@ -2561,7 +2440,6 @@ Toshiki Shima <hayabusa1419@gmail.com>
 Totoro W <tw19881113@gmail.com>
 Travis Bischel <travis.bischel@gmail.com>
 Travis Cline <travis.cline@gmail.com>
-Trevor Dixon <trevordixon@gmail.com>
 Trevor Strohman <trevor.strohman@gmail.com>
 Trey Lawrence <lawrence.trey@gmail.com>
 Trey Roessig <trey.roessig@gmail.com>
@@ -2585,7 +2463,6 @@ Tzach Shabtay <tzachshabtay@gmail.com>
 Tzu-Chiao Yeh <su3g4284zo6y7@gmail.com>
 Tzu-Jung Lee <roylee17@currant.com>
 Udalov Max <re.udalov@gmail.com>
-Uddeshya Singh <singhuddeshyaofficial@gmail.com>
 Ugorji Nwoke <ugorji@gmail.com>
 Ulf Holm Nielsen <doktor@dyregod.dk>
 Ulrich Kunitz <uli.kunitz@gmail.com>
@@ -2598,7 +2475,6 @@ Vadim Grek <vadimprog@gmail.com>
 Vadim Vygonets <unixdj@gmail.com>
 Val Polouchkine <vpolouch@justin.tv>
 Valentin Vidic <vvidic@valentin-vidic.from.hr>
-Vaughn Iverson <vsivsi@yahoo.com>
 Vee Zhang <veezhang@126.com> <vveezhang@gmail.com>
 Vega Garcia Luis Alfonso <vegacom@gmail.com>
 Venil Noronha <veniln@vmware.com>
@@ -2615,7 +2491,6 @@ Vincent Batts <vbatts@hashbangbash.com> <vbatts@gmail.com>
 Vincent Vanackere <vincent.vanackere@gmail.com>
 Vinu Rajashekhar <vinutheraj@gmail.com>
 Vish Subramanian <vish@google.com>
-Vishal Dalwadi <dalwadivishal26@gmail.com>
 Vishvananda Ishaya <vishvananda@gmail.com>
 Visweswara R <r.visweswara@gmail.com>
 Vitaly Zdanevich <zdanevich.vitaly@ya.ru>
@@ -2651,7 +2526,6 @@ Wei Guangjing <vcc.163@gmail.com>
 Wei Xiao <wei.xiao@arm.com>
 Wei Xikai <xykwei@gmail.com>
 Weichao Tang <tevic.tt@gmail.com>
-Weixie Cui <cuiweixie@gmail.com> <523516579@qq.com>
 Wembley G. Leach, Jr <wembley.gl@gmail.com>
 Wenlei (Frank) He <wlhe@google.com>
 Wenzel Lowe <lowewenzel@gmail.com>
@@ -2667,7 +2541,6 @@ Willem van der Schyff <willemvds@gmail.com>
 William Chan <willchan@chromium.org>
 William Chang <mr.williamchang@gmail.com>
 William Josephson <wjosephson@gmail.com>
-William Langford <wlangfor@gmail.com>
 William Orr <will@worrbase.com> <ay1244@gmail.com>
 William Poussier <william.poussier@gmail.com>
 Wisdom Omuya <deafgoat@gmail.com>
@@ -2676,7 +2549,6 @@ Xi Ruoyao <xry23333@gmail.com>
 Xia Bin <snyh@snyh.org>
 Xiangdong Ji <xiangdong.ji@arm.com>
 Xiaodong Liu <teaofmoli@gmail.com>
-Xing Gao <18340825824@163.com>
 Xing Xing <mikespook@gmail.com>
 Xingqang Bai <bxq2011hust@qq.com>
 Xu Fei <badgangkiller@gmail.com>
@@ -2698,7 +2570,6 @@ Yasha Bubnov <girokompass@gmail.com>
 Yasser Abdolmaleki <yasser@yasser.ca>
 Yasuharu Goto <matope.ono@gmail.com>
 Yasuhiro Matsumoto <mattn.jp@gmail.com>
-Yasutaka Shinzaki <shinzaki@yasu26.tech>
 Yasuyuki Oka <yasuyk@gmail.com>
 Yazen Shunnar <yazen.shunnar@gmail.com>
 Yestin Sun <ylh@pdx.edu>
@@ -2711,18 +2582,14 @@ Yorman Arias <cixtords@gmail.com>
 Yoshiyuki Kanno <nekotaroh@gmail.com> <yoshiyuki.kanno@stoic.co.jp>
 Yoshiyuki Mineo <yoshiyuki.mineo@gmail.com>
 Yosuke Akatsuka <yosuke.akatsuka@gmail.com>
-Youfu Zhang <zhangyoufu@gmail.com>
 Yu Heng Zhang <annita.zhang@cn.ibm.com>
 Yu Xuan Zhang <zyxsh@cn.ibm.com>
-Yu, Li-Yu <afg984@gmail.com>
 Yuichi Kishimoto <yk2220s@gmail.com>
 Yuichi Nishiwaki <yuichi.nishiwaki@gmail.com>
 Yuji Yaginuma <yuuji.yaginuma@gmail.com>
-Yuki Ito <mrno110y@gmail.com>
 Yuki OKUSHI <huyuumi.dev@gmail.com>
 Yuki Yugui Sonoda <yugui@google.com>
 Yukihiro Nishinaka <6elpinal@gmail.com>
-YunQiang Su <syq@debian.org>
 Yury Smolsky <yury@smolsky.by>
 Yusuke Kagiwada <block.rxckin.beats@gmail.com>
 Yuusei Kuwana <kuwana@kumama.org>
@@ -2731,7 +2598,6 @@ Yves Junqueira <yvesj@google.com> <yves.junqueira@gmail.com>
 Zac Bergquist <zbergquist99@gmail.com>
 Zach Bintliff <zbintliff@gmail.com>
 Zach Gershman <zachgersh@gmail.com>
-Zach Hoffman <zrhoffman@apache.org>
 Zach Jones <zachj1@gmail.com>
 Zachary Amsden <zach@thundertoken.com>
 Zachary Gershman <zgershman@pivotal.io>
@@ -2750,7 +2616,6 @@ Zhou Peng <p@ctriple.cn>
 Ziad Hatahet <hatahet@gmail.com>
 Ziheng Liu <lzhfromustc@gmail.com>
 Zorion Arrizabalaga <zorionk@gmail.com>
-Zvonimir Pavlinovic <zpavlinovic@google.com>
 Zyad A. Ali <zyad.ali.me@gmail.com>
 Максадбек Ахмедов <a.maksadbek@gmail.com>
 Максим Федосеев <max.faceless.frei@gmail.com>
--- a/README.md
+++ b/README.md
@@ -3,7 +3,7 @@
 Go is an open source programming language that makes it easy to build simple,
 reliable, and efficient software.

-![Gopher image](https://golang.org/doc/gopher/fiveyears.jpg)
+![Gopher image](doc/gopher/fiveyears.jpg)
 *Gopher image by [Renee French][rf], licensed under [Creative Commons 3.0 Attributions license][cc3-by].*

 Our canonical Git repository is located at https://go.googlesource.com/go.
--- a/1
+++ b/1
@@ -0,0 +1 @@
+go1.16.1
--- a/api/except.txt
+++ b/api/except.txt
@@ -1,7 +1,4 @@
 pkg encoding/json, method (*RawMessage) MarshalJSON() ([]uint8, error)
-pkg math, const MaxFloat64 = 1.79769e+308  // 179769313486231570814527423731704356798100000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000
-pkg math, const SmallestNonzeroFloat32 = 1.4013e-45  // 17516230804060213386546619791123951641/12500000000000000000000000000000000000000000000000000000000000000000000000000000000
-pkg math, const SmallestNonzeroFloat64 = 4.94066e-324  // 4940656458412465441765687928682213723651/1000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000
 pkg math/big, const MaxBase = 36
 pkg math/big, type Word uintptr
 pkg net, func ListenUnixgram(string, *UnixAddr) (*UDPConn, error)
--- a/api/go1.17.txt
+++ b/api/go1.17.txt
@@ -1,195 +0,0 @@
-pkg archive/zip, method (*File) OpenRaw() (io.Reader, error)
-pkg archive/zip, method (*Writer) Copy(*File) error
-pkg archive/zip, method (*Writer) CreateRaw(*FileHeader) (io.Writer, error)
-pkg compress/lzw, method (*Reader) Close() error
-pkg compress/lzw, method (*Reader) Read([]uint8) (int, error)
-pkg compress/lzw, method (*Reader) Reset(io.Reader, Order, int)
-pkg compress/lzw, method (*Writer) Close() error
-pkg compress/lzw, method (*Writer) Reset(io.Writer, Order, int)
-pkg compress/lzw, method (*Writer) Write([]uint8) (int, error)
-pkg compress/lzw, type Reader struct
-pkg compress/lzw, type Writer struct
-pkg crypto/tls, method (*CertificateRequestInfo) Context() context.Context
-pkg crypto/tls, method (*ClientHelloInfo) Context() context.Context
-pkg crypto/tls, method (*Conn) HandshakeContext(context.Context) error
-pkg database/sql, method (*NullByte) Scan(interface{}) error
-pkg database/sql, method (*NullInt16) Scan(interface{}) error
-pkg database/sql, method (NullByte) Value() (driver.Value, error)
-pkg database/sql, method (NullInt16) Value() (driver.Value, error)
-pkg database/sql, type NullByte struct
-pkg database/sql, type NullByte struct, Byte uint8
-pkg database/sql, type NullByte struct, Valid bool
-pkg database/sql, type NullInt16 struct
-pkg database/sql, type NullInt16 struct, Int16 int16
-pkg database/sql, type NullInt16 struct, Valid bool
-pkg debug/elf, const SHT_MIPS_ABIFLAGS = 1879048234
-pkg debug/elf, const SHT_MIPS_ABIFLAGS SectionType
-pkg encoding/csv, method (*Reader) FieldPos(int) (int, int)
-pkg go/build, type Context struct, ToolTags []string
-pkg go/parser, const SkipObjectResolution = 64
-pkg go/parser, const SkipObjectResolution Mode
-pkg image, method (*Alpha) RGBA64At(int, int) color.RGBA64
-pkg image, method (*Alpha) SetRGBA64(int, int, color.RGBA64)
-pkg image, method (*Alpha16) RGBA64At(int, int) color.RGBA64
-pkg image, method (*Alpha16) SetRGBA64(int, int, color.RGBA64)
-pkg image, method (*CMYK) RGBA64At(int, int) color.RGBA64
-pkg image, method (*CMYK) SetRGBA64(int, int, color.RGBA64)
-pkg image, method (*Gray) RGBA64At(int, int) color.RGBA64
-pkg image, method (*Gray) SetRGBA64(int, int, color.RGBA64)
-pkg image, method (*Gray16) RGBA64At(int, int) color.RGBA64
-pkg image, method (*Gray16) SetRGBA64(int, int, color.RGBA64)
-pkg image, method (*NRGBA) RGBA64At(int, int) color.RGBA64
-pkg image, method (*NRGBA) SetRGBA64(int, int, color.RGBA64)
-pkg image, method (*NRGBA64) RGBA64At(int, int) color.RGBA64
-pkg image, method (*NRGBA64) SetRGBA64(int, int, color.RGBA64)
-pkg image, method (*NYCbCrA) RGBA64At(int, int) color.RGBA64
-pkg image, method (*Paletted) RGBA64At(int, int) color.RGBA64
-pkg image, method (*Paletted) SetRGBA64(int, int, color.RGBA64)
-pkg image, method (*RGBA) RGBA64At(int, int) color.RGBA64
-pkg image, method (*RGBA) SetRGBA64(int, int, color.RGBA64)
-pkg image, method (*Uniform) RGBA64At(int, int) color.RGBA64
-pkg image, method (*YCbCr) RGBA64At(int, int) color.RGBA64
-pkg image, method (Rectangle) RGBA64At(int, int) color.RGBA64
-pkg image, type RGBA64Image interface { At, Bounds, ColorModel, RGBA64At }
-pkg image, type RGBA64Image interface, At(int, int) color.Color
-pkg image, type RGBA64Image interface, Bounds() Rectangle
-pkg image, type RGBA64Image interface, ColorModel() color.Model
-pkg image, type RGBA64Image interface, RGBA64At(int, int) color.RGBA64
-pkg image/draw, type RGBA64Image interface { At, Bounds, ColorModel, RGBA64At, Set, SetRGBA64 }
-pkg image/draw, type RGBA64Image interface, At(int, int) color.Color
-pkg image/draw, type RGBA64Image interface, Bounds() image.Rectangle
-pkg image/draw, type RGBA64Image interface, ColorModel() color.Model
-pkg image/draw, type RGBA64Image interface, RGBA64At(int, int) color.RGBA64
-pkg image/draw, type RGBA64Image interface, Set(int, int, color.Color)
-pkg image/draw, type RGBA64Image interface, SetRGBA64(int, int, color.RGBA64)
-pkg io/fs, func FileInfoToDirEntry(FileInfo) DirEntry
-pkg math, const MaxFloat64 = 1.79769e+308  // 179769313486231570814527423731704356798070567525844996598917476803157260780028538760589558632766878171540458953514382464234321326889464182768467546703537516986049910576551282076245490090389328944075868508455133942304583236903222948165808559332123348274797826204144723168738177180919299881250404026184124858368
-pkg math, const MaxInt = 9223372036854775807
-pkg math, const MaxInt ideal-int
-pkg math, const MaxUint = 18446744073709551615
-pkg math, const MaxUint ideal-int
-pkg math, const MinInt = -9223372036854775808
-pkg math, const MinInt ideal-int
-pkg math, const SmallestNonzeroFloat32 = 1.4013e-45  // 1/713623846352979940529142984724747568191373312
-pkg math, const SmallestNonzeroFloat64 = 4.94066e-324  // 1/202402253307310618352495346718917307049556649764142118356901358027430339567995346891960383701437124495187077864316811911389808737385793476867013399940738509921517424276566361364466907742093216341239767678472745068562007483424692698618103355649159556340810056512358769552333414615230502532186327508646006263307707741093494784
-pkg net, method (*ParseError) Temporary() bool
-pkg net, method (*ParseError) Timeout() bool
-pkg net, method (IP) IsPrivate() bool
-pkg net/http, func AllowQuerySemicolons(Handler) Handler
-pkg net/url, method (Values) Has(string) bool
-pkg reflect, func VisibleFields(Type) []StructField
-pkg reflect, method (Method) IsExported() bool
-pkg reflect, method (StructField) IsExported() bool
-pkg reflect, method (Value) CanConvert(Type) bool
-pkg runtime/cgo (darwin-amd64-cgo), func NewHandle(interface{}) Handle
-pkg runtime/cgo (darwin-amd64-cgo), method (Handle) Delete()
-pkg runtime/cgo (darwin-amd64-cgo), method (Handle) Value() interface{}
-pkg runtime/cgo (darwin-amd64-cgo), type Handle uintptr
-pkg runtime/cgo (freebsd-386-cgo), func NewHandle(interface{}) Handle
-pkg runtime/cgo (freebsd-386-cgo), method (Handle) Delete()
-pkg runtime/cgo (freebsd-386-cgo), method (Handle) Value() interface{}
-pkg runtime/cgo (freebsd-386-cgo), type Handle uintptr
-pkg runtime/cgo (freebsd-amd64-cgo), func NewHandle(interface{}) Handle
-pkg runtime/cgo (freebsd-amd64-cgo), method (Handle) Delete()
-pkg runtime/cgo (freebsd-amd64-cgo), method (Handle) Value() interface{}
-pkg runtime/cgo (freebsd-amd64-cgo), type Handle uintptr
-pkg runtime/cgo (freebsd-arm-cgo), func NewHandle(interface{}) Handle
-pkg runtime/cgo (freebsd-arm-cgo), method (Handle) Delete()
-pkg runtime/cgo (freebsd-arm-cgo), method (Handle) Value() interface{}
-pkg runtime/cgo (freebsd-arm-cgo), type Handle uintptr
-pkg runtime/cgo (linux-386-cgo), func NewHandle(interface{}) Handle
-pkg runtime/cgo (linux-386-cgo), method (Handle) Delete()
-pkg runtime/cgo (linux-386-cgo), method (Handle) Value() interface{}
-pkg runtime/cgo (linux-386-cgo), type Handle uintptr
-pkg runtime/cgo (linux-amd64-cgo), func NewHandle(interface{}) Handle
-pkg runtime/cgo (linux-amd64-cgo), method (Handle) Delete()
-pkg runtime/cgo (linux-amd64-cgo), method (Handle) Value() interface{}
-pkg runtime/cgo (linux-amd64-cgo), type Handle uintptr
-pkg runtime/cgo (linux-arm-cgo), func NewHandle(interface{}) Handle
-pkg runtime/cgo (linux-arm-cgo), method (Handle) Delete()
-pkg runtime/cgo (linux-arm-cgo), method (Handle) Value() interface{}
-pkg runtime/cgo (linux-arm-cgo), type Handle uintptr
-pkg runtime/cgo (netbsd-386-cgo), func NewHandle(interface{}) Handle
-pkg runtime/cgo (netbsd-386-cgo), method (Handle) Delete()
-pkg runtime/cgo (netbsd-386-cgo), method (Handle) Value() interface{}
-pkg runtime/cgo (netbsd-386-cgo), type Handle uintptr
-pkg runtime/cgo (netbsd-amd64-cgo), func NewHandle(interface{}) Handle
-pkg runtime/cgo (netbsd-amd64-cgo), method (Handle) Delete()
-pkg runtime/cgo (netbsd-amd64-cgo), method (Handle) Value() interface{}
-pkg runtime/cgo (netbsd-amd64-cgo), type Handle uintptr
-pkg runtime/cgo (netbsd-arm-cgo), func NewHandle(interface{}) Handle
-pkg runtime/cgo (netbsd-arm-cgo), method (Handle) Delete()
-pkg runtime/cgo (netbsd-arm-cgo), method (Handle) Value() interface{}
-pkg runtime/cgo (netbsd-arm-cgo), type Handle uintptr
-pkg runtime/cgo (netbsd-arm64-cgo), func NewHandle(interface{}) Handle
-pkg runtime/cgo (netbsd-arm64-cgo), method (Handle) Delete()
-pkg runtime/cgo (netbsd-arm64-cgo), method (Handle) Value() interface{}
-pkg runtime/cgo (netbsd-arm64-cgo), type Handle uintptr
-pkg runtime/cgo (openbsd-386-cgo), func NewHandle(interface{}) Handle
-pkg runtime/cgo (openbsd-386-cgo), method (Handle) Delete()
-pkg runtime/cgo (openbsd-386-cgo), method (Handle) Value() interface{}
-pkg runtime/cgo (openbsd-386-cgo), type Handle uintptr
-pkg runtime/cgo (openbsd-amd64-cgo), func NewHandle(interface{}) Handle
-pkg runtime/cgo (openbsd-amd64-cgo), method (Handle) Delete()
-pkg runtime/cgo (openbsd-amd64-cgo), method (Handle) Value() interface{}
-pkg runtime/cgo (openbsd-amd64-cgo), type Handle uintptr
-pkg strconv, func QuotedPrefix(string) (string, error)
-pkg sync/atomic, method (*Value) CompareAndSwap(interface{}, interface{}) bool
-pkg sync/atomic, method (*Value) Swap(interface{}) interface{}
-pkg syscall (netbsd-386), const SYS_WAIT6 = 481
-pkg syscall (netbsd-386), const SYS_WAIT6 ideal-int
-pkg syscall (netbsd-386), const WEXITED = 32
-pkg syscall (netbsd-386), const WEXITED ideal-int
-pkg syscall (netbsd-386-cgo), const SYS_WAIT6 = 481
-pkg syscall (netbsd-386-cgo), const SYS_WAIT6 ideal-int
-pkg syscall (netbsd-386-cgo), const WEXITED = 32
-pkg syscall (netbsd-386-cgo), const WEXITED ideal-int
-pkg syscall (netbsd-amd64), const SYS_WAIT6 = 481
-pkg syscall (netbsd-amd64), const SYS_WAIT6 ideal-int
-pkg syscall (netbsd-amd64), const WEXITED = 32
-pkg syscall (netbsd-amd64), const WEXITED ideal-int
-pkg syscall (netbsd-amd64-cgo), const SYS_WAIT6 = 481
-pkg syscall (netbsd-amd64-cgo), const SYS_WAIT6 ideal-int
-pkg syscall (netbsd-amd64-cgo), const WEXITED = 32
-pkg syscall (netbsd-amd64-cgo), const WEXITED ideal-int
-pkg syscall (netbsd-arm), const SYS_WAIT6 = 481
-pkg syscall (netbsd-arm), const SYS_WAIT6 ideal-int
-pkg syscall (netbsd-arm), const WEXITED = 32
-pkg syscall (netbsd-arm), const WEXITED ideal-int
-pkg syscall (netbsd-arm-cgo), const SYS_WAIT6 = 481
-pkg syscall (netbsd-arm-cgo), const SYS_WAIT6 ideal-int
-pkg syscall (netbsd-arm-cgo), const WEXITED = 32
-pkg syscall (netbsd-arm-cgo), const WEXITED ideal-int
-pkg syscall (netbsd-arm64), const SYS_WAIT6 = 481
-pkg syscall (netbsd-arm64), const SYS_WAIT6 ideal-int
-pkg syscall (netbsd-arm64), const WEXITED = 32
-pkg syscall (netbsd-arm64), const WEXITED ideal-int
-pkg syscall (netbsd-arm64-cgo), const SYS_WAIT6 = 481
-pkg syscall (netbsd-arm64-cgo), const SYS_WAIT6 ideal-int
-pkg syscall (netbsd-arm64-cgo), const WEXITED = 32
-pkg syscall (netbsd-arm64-cgo), const WEXITED ideal-int
-pkg syscall (openbsd-386), const MSG_CMSG_CLOEXEC = 2048
-pkg syscall (openbsd-386), const MSG_CMSG_CLOEXEC ideal-int
-pkg syscall (openbsd-386-cgo), const MSG_CMSG_CLOEXEC = 2048
-pkg syscall (openbsd-386-cgo), const MSG_CMSG_CLOEXEC ideal-int
-pkg syscall (openbsd-amd64), const MSG_CMSG_CLOEXEC = 2048
-pkg syscall (openbsd-amd64), const MSG_CMSG_CLOEXEC ideal-int
-pkg syscall (openbsd-amd64-cgo), const MSG_CMSG_CLOEXEC = 2048
-pkg syscall (openbsd-amd64-cgo), const MSG_CMSG_CLOEXEC ideal-int
-pkg syscall (windows-386), type SysProcAttr struct, AdditionalInheritedHandles []Handle
-pkg syscall (windows-386), type SysProcAttr struct, ParentProcess Handle
-pkg syscall (windows-amd64), type SysProcAttr struct, AdditionalInheritedHandles []Handle
-pkg syscall (windows-amd64), type SysProcAttr struct, ParentProcess Handle
-pkg testing, method (*B) Setenv(string, string)
-pkg testing, method (*T) Setenv(string, string)
-pkg testing, type TB interface, Setenv(string, string)
-pkg text/template/parse, const SkipFuncCheck = 2
-pkg text/template/parse, const SkipFuncCheck Mode
-pkg time, const Layout = "01/02 03:04:05PM '06 -0700"
-pkg time, const Layout ideal-string
-pkg time, func UnixMicro(int64) Time
-pkg time, func UnixMilli(int64) Time
-pkg time, method (Time) GoString() string
-pkg time, method (Time) IsDST() bool
-pkg time, method (Time) UnixMicro() int64
-pkg time, method (Time) UnixMilli() int64
--- a/codereview.cfg
+++ b/codereview.cfg
@@ -1,2 +0,0 @@
-branch: dev.typeparams
-parent-branch: master
--- a/doc/asm.html
+++ b/doc/asm.html
@@ -166,7 +166,7 @@ jumps and branches.
 </li>

 <li>
-<code>SP</code>: Stack pointer: the highest address within the local stack frame.
+<code>SP</code>: Stack pointer: top of stack.
 </li>

 </ul>
@@ -216,7 +216,7 @@ If a Go prototype does not name its result, the expected assembly name is <code>
 The <code>SP</code> pseudo-register is a virtual stack pointer
 used to refer to frame-local variables and the arguments being
 prepared for function calls.
-It points to the highest address within the local stack frame, so references should use negative offsets
+It points to the top of the local stack frame, so references should use negative offsets
 in the range [−framesize, 0):
 <code>x-8(SP)</code>, <code>y-4(SP)</code>, and so on.
 </p>
@@ -409,7 +409,7 @@ The linker will choose one of the duplicates to use.
 (For <code>TEXT</code> items.)
 Don't insert the preamble to check if the stack must be split.
 The frame for the routine, plus anything it calls, must fit in the
-spare space remaining in the current stack segment.
+spare space at the top of the stack segment.
 Used to protect routines such as the stack splitting code itself.
 </li>
 <li>
@@ -460,7 +460,7 @@ Only valid on functions that declare a frame size of 0.
 <code>TOPFRAME</code> = 2048
 <br>
 (For <code>TEXT</code> items.)
-Function is the outermost frame of the call stack. Traceback should stop at this function.
+Function is the top of the call stack. Traceback should stop at this function.
 </li>
 </ul>

@@ -827,6 +827,10 @@ The other codes are <code>-&gt;</code> (arithmetic right shift),

 <h3 id="arm64">ARM64</h3>

+<p>
+The ARM64 port is in an experimental state.
+</p>
+
 <p>
 <code>R18</code> is the "platform register", reserved on the Apple platform.
 To prevent accidental misuse, the register is named <code>R18_PLATFORM</code>.
--- a/doc/go1.16.html
+++ b/doc/go1.16.html
--- a/doc/go1.17.html
+++ b/doc/go1.17.html
--- a/doc/go_spec.html
+++ b/doc/go_spec.html
@@ -1,6 +1,6 @@
 <!--{
 	"Title": "The Go Programming Language Specification",
-	"Subtitle": "Version of Jul 26, 2021",
+	"Subtitle": "Version of Feb 10, 2021",
 	"Path": "/ref/spec"
 }-->

@@ -490,8 +490,8 @@ After a backslash, certain single-character escapes represent special values:
 \n   U+000A line feed or newline
 \r   U+000D carriage return
 \t   U+0009 horizontal tab
-\v   U+000B vertical tab
-\\   U+005C backslash
+\v   U+000b vertical tab
+\\   U+005c backslash
 \'   U+0027 single quote  (valid escape only within rune literals)
 \"   U+0022 double quote  (valid escape only within string literals)
 </pre>
@@ -830,7 +830,7 @@ The underlying type of <code>[]B1</code>, <code>B3</code>, and <code>B4</code> i

 <h3 id="Method_sets">Method sets</h3>
 <p>
-A type has a (possibly empty) <i>method set</i> associated with it.
+A type may have a <i>method set</i> associated with it.
 The method set of an <a href="#Interface_types">interface type</a> is its interface.
 The method set of any other type <code>T</code> consists of all
 <a href="#Method_declarations">methods</a> declared with receiver type <code>T</code>.
@@ -3532,9 +3532,9 @@ within <code>Greeting</code>, <code>who</code> will have the value
 </p>

 <p>
-If the final argument is assignable to a slice type <code>[]T</code> and
-is followed by <code>...</code>, it is passed unchanged as the value
-for a <code>...T</code> parameter. In this case no new slice is created.
+If the final argument is assignable to a slice type <code>[]T</code>, it is
+passed unchanged as the value for a <code>...T</code> parameter if the argument
+is followed by <code>...</code>. In this case no new slice is created.
 </p>

 <p>
@@ -3681,8 +3681,8 @@ The bitwise logical and shift operators apply to integers only.
 ^    bitwise XOR            integers
 &amp;^   bit clear (AND NOT)    integers

-&lt;&lt;   left shift             integer &lt;&lt; integer &gt;= 0
-&gt;&gt;   right shift            integer &gt;&gt; integer &gt;= 0
+&lt;&lt;   left shift             integer &lt;&lt; unsigned integer
+&gt;&gt;   right shift            integer &gt;&gt; unsigned integer
 </pre>


@@ -4164,10 +4164,6 @@ in any of these cases:
 	<li>
 	<code>x</code> is a string and <code>T</code> is a slice of bytes or runes.
 	</li>
-	<li>
-	<code>x</code> is a slice, <code>T</code> is a pointer to an array,
-	and the slice and array types have <a href="#Type_identity">identical</a> element types.
-	</li>
 </ul>

 <p>
@@ -4318,28 +4314,6 @@ MyRunes("白鵬翔")           // []rune{0x767d, 0x9d6c, 0x7fd4}
 </li>
 </ol>

-<h4 id="Conversions_from_slice_to_array_pointer">Conversions from slice to array pointer</h4>
-
-<p>
-Converting a slice to an array pointer yields a pointer to the underlying array of the slice.
-If the <a href="#Length_and_capacity">length</a> of the slice is less than the length of the array,
-a <a href="#Run_time_panics">run-time panic</a> occurs.
-</p>
-
-<pre>
-s := make([]byte, 2, 4)
-s0 := (*[0]byte)(s)      // s0 != nil
-s1 := (*[1]byte)(s[1:])  // &amp;s1[0] == &amp;s[1]
-s2 := (*[2]byte)(s)      // &amp;s2[0] == &amp;s[0]
-s4 := (*[4]byte)(s)      // panics: len([4]byte) > len(s)
-
-var t []string
-t0 := (*[0]string)(t)    // t0 == nil
-t1 := (*[1]string)(t)    // panics: len([1]string) > len(t)
-
-u := make([]byte, 0)
-u0 = (*[0]byte)(u)       // u0 != nil
-</pre>

 <h3 id="Constant_expressions">Constant expressions</h3>

@@ -4674,7 +4648,7 @@ The following built-in functions are not permitted in statement context:

 <pre>
 append cap complex imag len make new real
-unsafe.Add unsafe.Alignof unsafe.Offsetof unsafe.Sizeof unsafe.Slice
+unsafe.Alignof unsafe.Offsetof unsafe.Sizeof
 </pre>

 <pre>
@@ -4913,7 +4887,7 @@ if x := f(); x &lt; y {

 <p>
 "Switch" statements provide multi-way execution.
-An expression or type is compared to the "cases"
+An expression or type specifier is compared to the "cases"
 inside the "switch" to determine which branch
 to execute.
 </p>
@@ -4957,9 +4931,9 @@ ExprSwitchCase = "case" ExpressionList | "default" .

 <p>
 If the switch expression evaluates to an untyped constant, it is first implicitly
-<a href="#Conversions">converted</a> to its <a href="#Constants">default type</a>.
+<a href="#Conversions">converted</a> to its <a href="#Constants">default type</a>;
+if it is an untyped boolean value, it is first implicitly converted to type <code>bool</code>.
 The predeclared untyped value <code>nil</code> cannot be used as a switch expression.
-The switch expression type must be <a href="#Comparison_operators">comparable</a>.
 </p>

 <p>
@@ -5024,7 +4998,7 @@ floating point, or string constants in case expressions.
 A type switch compares types rather than values. It is otherwise similar
 to an expression switch. It is marked by a special switch expression that
 has the form of a <a href="#Type_assertions">type assertion</a>
-using the keyword <code>type</code> rather than an actual type:
+using the reserved word <code>type</code> rather than an actual type:
 </p>

 <pre>
@@ -6715,10 +6689,6 @@ type Pointer *ArbitraryType
 func Alignof(variable ArbitraryType) uintptr
 func Offsetof(selector ArbitraryType) uintptr
 func Sizeof(variable ArbitraryType) uintptr
-
-type IntegerType int  // shorthand for an integer type; it is not a real type
-func Add(ptr Pointer, len IntegerType) Pointer
-func Slice(ptr *ArbitraryType, len IntegerType) []ArbitraryType
 </pre>

 <p>
@@ -6775,40 +6745,6 @@ Calls to <code>Alignof</code>, <code>Offsetof</code>, and
 <code>Sizeof</code> are compile-time constant expressions of type <code>uintptr</code>.
 </p>

-<p>
-The function <code>Add</code> adds <code>len</code> to <code>ptr</code>
-and returns the updated pointer <code>unsafe.Pointer(uintptr(ptr) + uintptr(len))</code>.
-The <code>len</code> argument must be of integer type or an untyped <a href="#Constants">constant</a>.
-A constant <code>len</code> argument must be <a href="#Representability">representable</a> by a value of type <code>int</code>;
-if it is an untyped constant it is given type <code>int</code>.
-The rules for <a href="/pkg/unsafe#Pointer">valid uses</a> of <code>Pointer</code> still apply.
-</p>
-
-<p>
-The function <code>Slice</code> returns a slice whose underlying array starts at <code>ptr</code>
-and whose length and capacity are <code>len</code>.
-<code>Slice(ptr, len)</code> is equivalent to
-</p>
-
-<pre>
-(*[len]ArbitraryType)(unsafe.Pointer(ptr))[:]
-</pre>
-
-<p>
-except that, as a special case, if <code>ptr</code>
-is <code>nil</code> and <code>len</code> is zero,
-<code>Slice</code> returns <code>nil</code>.
-</p>
-
-<p>
-The <code>len</code> argument must be of integer type or an untyped <a href="#Constants">constant</a>.
-A constant <code>len</code> argument must be non-negative and <a href="#Representability">representable</a> by a value of type <code>int</code>;
-if it is an untyped constant it is given type <code>int</code>.
-At run time, if <code>len</code> is negative,
-or if <code>ptr</code> is <code>nil</code> and <code>len</code> is not zero,
-a <a href="#Run_time_panics">run-time panic</a> occurs.
-</p>
-
 <h3 id="Size_and_alignment_guarantees">Size and alignment guarantees</h3>

 <p>
--- a/favicon.ico
+++ b/favicon.ico
--- a/misc/android/go_android_exec.go
+++ b/misc/android/go_android_exec.go
@@ -14,6 +14,7 @@ import (
 	"fmt"
 	"go/build"
 	"io"
+	"io/ioutil"
 	"log"
 	"os"
 	"os/exec"
@@ -275,7 +276,7 @@ func adbCopyGoroot() error {
 	if err := syscall.Flock(int(stat.Fd()), syscall.LOCK_EX); err != nil {
 		return err
 	}
-	s, err := io.ReadAll(stat)
+	s, err := ioutil.ReadAll(stat)
 	if err != nil {
 		return err
 	}
@@ -293,7 +294,7 @@ func adbCopyGoroot() error {
 	goroot := runtime.GOROOT()
 	// Build go for android.
 	goCmd := filepath.Join(goroot, "bin", "go")
-	tmpGo, err := os.CreateTemp("", "go_android_exec-cmd-go-*")
+	tmpGo, err := ioutil.TempFile("", "go_android_exec-cmd-go-*")
 	if err != nil {
 		return err
 	}
--- a/misc/cgo/errors/argposition_test.go
+++ b/misc/cgo/errors/argposition_test.go
@@ -1,134 +0,0 @@
-// Copyright 2021 The Go Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style
-// license that can be found in the LICENSE file.
-
-// Issue 42580: cmd/cgo: shifting identifier position in ast
-
-package errorstest
-
-import (
-	"bytes"
-	"fmt"
-	"go/ast"
-	"go/parser"
-	"go/token"
-	"io/ioutil"
-	"os"
-	"os/exec"
-	"path/filepath"
-	"strings"
-	"testing"
-)
-
-type ShortPosition struct {
-	Line    int
-	Column  int
-	Visited bool
-}
-
-type IdentPositionInfo map[string][]ShortPosition
-
-type Visitor struct {
-	identPosInfo IdentPositionInfo
-	fset         *token.FileSet
-	t            *testing.T
-}
-
-func (v *Visitor) Visit(node ast.Node) ast.Visitor {
-	if ident, ok := node.(*ast.Ident); ok {
-		if expectedPositions, ok := v.identPosInfo[ident.Name]; ok {
-			gotMatch := false
-			var errorMessage strings.Builder
-			for caseIndex, expectedPos := range expectedPositions {
-				actualPosition := v.fset.PositionFor(ident.Pos(), true)
-				errorOccured := false
-				if expectedPos.Line != actualPosition.Line {
-					fmt.Fprintf(&errorMessage, "wrong line number for ident %s: expected: %d got: %d\n", ident.Name, expectedPos.Line, actualPosition.Line)
-					errorOccured = true
-				}
-				if expectedPos.Column != actualPosition.Column {
-					fmt.Fprintf(&errorMessage, "wrong column number for ident %s: expected: %d got: %d\n", ident.Name, expectedPos.Column, actualPosition.Column)
-					errorOccured = true
-				}
-				if errorOccured {
-					continue
-				}
-				gotMatch = true
-				expectedPositions[caseIndex].Visited = true
-			}
-
-			if !gotMatch {
-				v.t.Errorf(errorMessage.String())
-			}
-		}
-	}
-	return v
-}
-
-func TestArgumentsPositions(t *testing.T) {
-	testdata, err := filepath.Abs("testdata")
-	if err != nil {
-		t.Fatal(err)
-	}
-
-	tmpPath := t.TempDir()
-
-	dir := filepath.Join(tmpPath, "src", "testpositions")
-	if err := os.MkdirAll(dir, 0755); err != nil {
-		t.Fatal(err)
-	}
-
-	cmd := exec.Command("go", "tool", "cgo",
-		"-srcdir", testdata,
-		"-objdir", dir,
-		"issue42580.go")
-	cmd.Stderr = new(bytes.Buffer)
-
-	err = cmd.Run()
-	if err != nil {
-		t.Fatalf("%s: %v\n%s", cmd, err, cmd.Stderr)
-	}
-	mainProcessed, err := ioutil.ReadFile(filepath.Join(dir, "issue42580.cgo1.go"))
-	if err != nil {
-		t.Fatal(err)
-	}
-	fset := token.NewFileSet()
-	f, err := parser.ParseFile(fset, "", mainProcessed, parser.AllErrors)
-	if err != nil {
-		fmt.Println(err)
-		return
-	}
-
-	expectation := IdentPositionInfo{
-		"checkedPointer": []ShortPosition{
-			ShortPosition{
-				Line:   32,
-				Column: 56,
-			},
-		},
-		"singleInnerPointerChecked": []ShortPosition{
-			ShortPosition{
-				Line:   37,
-				Column: 91,
-			},
-		},
-		"doublePointerChecked": []ShortPosition{
-			ShortPosition{
-				Line:   42,
-				Column: 91,
-			},
-		},
-	}
-	for _, decl := range f.Decls {
-		if fdecl, ok := decl.(*ast.FuncDecl); ok {
-			ast.Walk(&Visitor{expectation, fset, t}, fdecl.Body)
-		}
-	}
-	for ident, positions := range expectation {
-		for _, position := range positions {
-			if !position.Visited {
-				t.Errorf("Position %d:%d missed for %s ident", position.Line, position.Column, ident)
-			}
-		}
-	}
-}
--- a/misc/cgo/errors/badsym_test.go
+++ b/misc/cgo/errors/badsym_test.go
@@ -6,6 +6,7 @@ package errorstest

 import (
 	"bytes"
+	"io/ioutil"
 	"os"
 	"os/exec"
 	"path/filepath"
@@ -54,7 +55,7 @@ func TestBadSymbol(t *testing.T) {

 	makeFile := func(mdir, base, source string) string {
 		ret := filepath.Join(mdir, base)
-		if err := os.WriteFile(ret, []byte(source), 0644); err != nil {
+		if err := ioutil.WriteFile(ret, []byte(source), 0644); err != nil {
 			t.Fatal(err)
 		}
 		return ret
@@ -99,7 +100,7 @@ func TestBadSymbol(t *testing.T) {
 	// _cgo_import.go.

 	rewrite := func(from, to string) {
-		obj, err := os.ReadFile(from)
+		obj, err := ioutil.ReadFile(from)
 		if err != nil {
 			t.Fatal(err)
 		}
@@ -114,7 +115,7 @@ func TestBadSymbol(t *testing.T) {

 		obj = bytes.ReplaceAll(obj, []byte(magicInput), []byte(magicReplace))

-		if err := os.WriteFile(to, obj, 0644); err != nil {
+		if err := ioutil.WriteFile(to, obj, 0644); err != nil {
 			t.Fatal(err)
 		}
 	}
--- a/misc/cgo/errors/errors_test.go
+++ b/misc/cgo/errors/errors_test.go
@@ -7,6 +7,7 @@ package errorstest
 import (
 	"bytes"
 	"fmt"
+	"io/ioutil"
 	"os"
 	"os/exec"
 	"path/filepath"
@@ -24,7 +25,7 @@ func check(t *testing.T, file string) {
 	t.Run(file, func(t *testing.T) {
 		t.Parallel()

-		contents, err := os.ReadFile(path(file))
+		contents, err := ioutil.ReadFile(path(file))
 		if err != nil {
 			t.Fatal(err)
 		}
@@ -40,8 +41,7 @@ func check(t *testing.T, file string) {
 			if len(frags) == 1 {
 				continue
 			}
-			frag := fmt.Sprintf(":%d:.*%s", i+1, frags[1])
-			re, err := regexp.Compile(frag)
+			re, err := regexp.Compile(string(frags[1]))
 			if err != nil {
 				t.Errorf("Invalid regexp after `ERROR HERE: `: %#q", frags[1])
 				continue
@@ -56,7 +56,7 @@ func check(t *testing.T, file string) {
 }

 func expect(t *testing.T, file string, errors []*regexp.Regexp) {
-	dir, err := os.MkdirTemp("", filepath.Base(t.Name()))
+	dir, err := ioutil.TempDir("", filepath.Base(t.Name()))
 	if err != nil {
 		t.Fatal(err)
 	}
--- a/misc/cgo/errors/ptr_test.go
+++ b/misc/cgo/errors/ptr_test.go
@@ -10,6 +10,7 @@ import (
 	"bytes"
 	"flag"
 	"fmt"
+	"io/ioutil"
 	"os"
 	"os/exec"
 	"path/filepath"
@@ -462,7 +463,7 @@ func buildPtrTests(t *testing.T) (dir, exe string) {
 		gopath = *tmp
 		dir = ""
 	} else {
-		d, err := os.MkdirTemp("", filepath.Base(t.Name()))
+		d, err := ioutil.TempDir("", filepath.Base(t.Name()))
 		if err != nil {
 			t.Fatal(err)
 		}
@@ -474,7 +475,7 @@ func buildPtrTests(t *testing.T) (dir, exe string) {
 	if err := os.MkdirAll(src, 0777); err != nil {
 		t.Fatal(err)
 	}
-	if err := os.WriteFile(filepath.Join(src, "go.mod"), []byte("module ptrtest"), 0666); err != nil {
+	if err := ioutil.WriteFile(filepath.Join(src, "go.mod"), []byte("module ptrtest"), 0666); err != nil {
 		t.Fatal(err)
 	}

@@ -534,10 +535,10 @@ func buildPtrTests(t *testing.T) (dir, exe string) {
 	fmt.Fprintf(&cgo1, "}\n\n")
 	fmt.Fprintf(&cgo1, "%s\n", ptrTestMain)

-	if err := os.WriteFile(filepath.Join(src, "cgo1.go"), cgo1.Bytes(), 0666); err != nil {
+	if err := ioutil.WriteFile(filepath.Join(src, "cgo1.go"), cgo1.Bytes(), 0666); err != nil {
 		t.Fatal(err)
 	}
-	if err := os.WriteFile(filepath.Join(src, "cgo2.go"), cgo2.Bytes(), 0666); err != nil {
+	if err := ioutil.WriteFile(filepath.Join(src, "cgo2.go"), cgo2.Bytes(), 0666); err != nil {
 		t.Fatal(err)
 	}

--- a/misc/cgo/errors/testdata/err2.go
+++ b/misc/cgo/errors/testdata/err2.go
@@ -40,15 +40,15 @@ func main() {
 	C.foop = x // ERROR HERE

 	// issue 13129: used to output error about C.unsignedshort with CC=clang
-	var x1 C.ushort
-	x1 = int(0) // ERROR HERE: C\.ushort
+	var x C.ushort
+	x = int(0) // ERROR HERE: C\.ushort

 	// issue 13423
 	_ = C.fopen() // ERROR HERE

 	// issue 13467
-	var x2 rune = '✈'
-	var _ rune = C.transform(x2) // ERROR HERE: C\.int
+	var x rune = '✈'
+	var _ rune = C.transform(x) // ERROR HERE: C\.int

 	// issue 13635: used to output error about C.unsignedchar.
 	// This test tests all such types.
@@ -91,18 +91,10 @@ func main() {

 	// issue 26745
 	_ = func(i int) int {
-		// typecheck reports at column 14 ('+'), but types2 reports at
-		// column 10 ('C').
-		// TODO(mdempsky): Investigate why, and see if types2 can be
-		// updated to match typecheck behavior.
-		return C.i + 1 // ERROR HERE: \b(10|14)\b
+		return C.i + 1 // ERROR HERE: :13
 	}
 	_ = func(i int) {
-		// typecheck reports at column 7 ('('), but types2 reports at
-		// column 8 ('i'). The types2 position is more correct, but
-		// updating typecheck here is fundamentally challenging because of
-		// IR limitations.
-		C.fi(i) // ERROR HERE: \b(7|8)\b
+		C.fi(i) // ERROR HERE: :6
 	}

 	C.fi = C.fi // ERROR HERE
--- a/misc/cgo/errors/testdata/issue42580.go
+++ b/misc/cgo/errors/testdata/issue42580.go
@@ -1,44 +0,0 @@
-// Copyright 2021 The Go Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style
-// license that can be found in the LICENSE file.
-
-// Issue 42580: cmd/cgo: shifting identifier position in ast
-
-package cgotest
-
-// typedef int (*intFunc) ();
-//
-// char* strarg = "";
-//
-// int func_with_char(char* arg, void* dummy)
-// {return 5;}
-//
-// int* get_arr(char* arg, void* dummy)
-// {return NULL;}
-import "C"
-import "unsafe"
-
-// Test variables
-var (
-	checkedPointer            = []byte{1}
-	doublePointerChecked      = []byte{1}
-	singleInnerPointerChecked = []byte{1}
-)
-
-// This test checks the positions of variable identifiers.
-// Changing the positions of the test variables idents after this point will break the test.
-
-func TestSingleArgumentCast() C.int {
-	retcode := C.func_with_char((*C.char)(unsafe.Pointer(&checkedPointer[0])), unsafe.Pointer(C.strarg))
-	return retcode
-}
-
-func TestSingleArgumentCastRecFuncAsSimpleArg() C.int {
-	retcode := C.func_with_char((*C.char)(unsafe.Pointer(C.get_arr((*C.char)(unsafe.Pointer(&singleInnerPointerChecked[0])), unsafe.Pointer(C.strarg)))), nil)
-	return retcode
-}
-
-func TestSingleArgumentCastRecFunc() C.int {
-	retcode := C.func_with_char((*C.char)(unsafe.Pointer(C.get_arr((*C.char)(unsafe.Pointer(&doublePointerChecked[0])), unsafe.Pointer(C.strarg)))), unsafe.Pointer(C.strarg))
-	return retcode
-}
--- a/misc/cgo/life/life_test.go
+++ b/misc/cgo/life/life_test.go
@@ -6,6 +6,7 @@ package life_test

 import (
 	"bytes"
+	"io/ioutil"
 	"log"
 	"os"
 	"os/exec"
@@ -20,7 +21,7 @@ func TestMain(m *testing.M) {
 }

 func testMain(m *testing.M) int {
-	GOPATH, err := os.MkdirTemp("", "cgolife")
+	GOPATH, err := ioutil.TempDir("", "cgolife")
 	if err != nil {
 		log.Panic(err)
 	}
@@ -37,7 +38,7 @@ func testMain(m *testing.M) int {
 		log.Panic(err)
 	}
 	os.Setenv("PWD", modRoot)
-	if err := os.WriteFile("go.mod", []byte("module cgolife\n"), 0666); err != nil {
+	if err := ioutil.WriteFile("go.mod", []byte("module cgolife\n"), 0666); err != nil {
 		log.Panic(err)
 	}

--- a/misc/cgo/stdio/stdio_test.go
+++ b/misc/cgo/stdio/stdio_test.go
@@ -6,6 +6,7 @@ package stdio_test

 import (
 	"bytes"
+	"io/ioutil"
 	"log"
 	"os"
 	"os/exec"
@@ -20,7 +21,7 @@ func TestMain(m *testing.M) {
 }

 func testMain(m *testing.M) int {
-	GOPATH, err := os.MkdirTemp("", "cgostdio")
+	GOPATH, err := ioutil.TempDir("", "cgostdio")
 	if err != nil {
 		log.Panic(err)
 	}
@@ -37,7 +38,7 @@ func testMain(m *testing.M) int {
 		log.Panic(err)
 	}
 	os.Setenv("PWD", modRoot)
-	if err := os.WriteFile("go.mod", []byte("module cgostdio\n"), 0666); err != nil {
+	if err := ioutil.WriteFile("go.mod", []byte("module cgostdio\n"), 0666); err != nil {
 		log.Panic(err)
 	}

--- a/misc/cgo/test/callback.go
+++ b/misc/cgo/test/callback.go
@@ -182,7 +182,7 @@ func testCallbackCallers(t *testing.T) {
 		"runtime.cgocallbackg1",
 		"runtime.cgocallbackg",
 		"runtime.cgocallback",
-		"runtime.systemstack_switch",
+		"runtime.asmcgocall",
 		"runtime.cgocall",
 		"test._Cfunc_callback",
 		"test.nestedCall.func1",
--- a/misc/cgo/test/cgo_test.go
+++ b/misc/cgo/test/cgo_test.go
@@ -59,7 +59,6 @@ func Test28896(t *testing.T)                 { test28896(t) }
 func Test30065(t *testing.T)                 { test30065(t) }
 func Test32579(t *testing.T)                 { test32579(t) }
 func Test31891(t *testing.T)                 { test31891(t) }
-func Test45451(t *testing.T)                 { test45451(t) }
 func TestAlign(t *testing.T)                 { testAlign(t) }
 func TestAtol(t *testing.T)                  { testAtol(t) }
 func TestBlocking(t *testing.T)              { testBlocking(t) }
@@ -81,7 +80,6 @@ func TestNamedEnum(t *testing.T)             { testNamedEnum(t) }
 func TestCastToEnum(t *testing.T)            { testCastToEnum(t) }
 func TestErrno(t *testing.T)                 { testErrno(t) }
 func TestFpVar(t *testing.T)                 { testFpVar(t) }
-func TestHandle(t *testing.T)                { testHandle(t) }
 func TestHelpers(t *testing.T)               { testHelpers(t) }
 func TestLibgcc(t *testing.T)                { testLibgcc(t) }
 func TestMultipleAssign(t *testing.T)        { testMultipleAssign(t) }
--- a/misc/cgo/test/issue1435.go
+++ b/misc/cgo/test/issue1435.go
@@ -8,8 +8,7 @@ package cgotest

 import (
 	"fmt"
-	"os"
-	"sort"
+	"io/ioutil"
 	"strings"
 	"syscall"
 	"testing"
@@ -65,7 +64,7 @@ import "C"
 func compareStatus(filter, expect string) error {
 	expected := filter + expect
 	pid := syscall.Getpid()
-	fs, err := os.ReadDir(fmt.Sprintf("/proc/%d/task", pid))
+	fs, err := ioutil.ReadDir(fmt.Sprintf("/proc/%d/task", pid))
 	if err != nil {
 		return fmt.Errorf("unable to find %d tasks: %v", pid, err)
 	}
@@ -73,7 +72,7 @@ func compareStatus(filter, expect string) error {
 	foundAThread := false
 	for _, f := range fs {
 		tf := fmt.Sprintf("/proc/%s/status", f.Name())
-		d, err := os.ReadFile(tf)
+		d, err := ioutil.ReadFile(tf)
 		if err != nil {
 			// There are a surprising number of ways this
 			// can error out on linux.  We've seen all of
@@ -106,23 +105,11 @@ func compareStatus(filter, expect string) error {
 				// "Pid:\t".
 			}
 			if strings.HasPrefix(line, filter) {
-				if line == expected {
-					foundAThread = true
-					break
+				if line != expected {
+					return fmt.Errorf("%q got:%q want:%q (bad) [pid=%d file:'%s' %v]\n", tf, line, expected, pid, string(d), expectedProc)
 				}
-				if filter == "Groups:" && strings.HasPrefix(line, "Groups:\t") {
-					// https://github.com/golang/go/issues/46145
-					// Containers don't reliably output this line in sorted order so manually sort and compare that.
-					a := strings.Split(line[8:], " ")
-					sort.Strings(a)
-					got := strings.Join(a, " ")
-					if got == expected[8:] {
-						foundAThread = true
-						break
-					}
-
-				}
-				return fmt.Errorf("%q got:%q want:%q (bad) [pid=%d file:'%s' %v]\n", tf, line, expected, pid, string(d), expectedProc)
+				foundAThread = true
+				break
 			}
 		}
 	}
--- a/misc/cgo/test/issue6997_linux.go
+++ b/misc/cgo/test/issue6997_linux.go
@@ -5,7 +5,7 @@
 // +build !android

 // Test that pthread_cancel works as expected
-// (NPTL uses SIGRTMIN to implement thread cancellation)
+// (NPTL uses SIGRTMIN to implement thread cancelation)
 // See https://golang.org/issue/6997
 package cgotest

@@ -17,10 +17,8 @@ extern int CancelThread();
 */
 import "C"

-import (
-	"testing"
-	"time"
-)
+import "testing"
+import "time"

 func test6997(t *testing.T) {
 	r := C.StartThread()
--- a/misc/cgo/test/issue8148.c
+++ b/misc/cgo/test/issue8148.c
@@ -1,11 +0,0 @@
-// Copyright 2014 The Go Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style
-// license that can be found in the LICENSE file.
-
-#include "_cgo_export.h"
-
-int get8148(void) {
-	T t;
-	t.i = 42;
-	return issue8148Callback(&t);
-}
--- a/misc/cgo/test/issue8148.go
+++ b/misc/cgo/test/issue8148.go
@@ -10,7 +10,14 @@ package cgotest

 /*
 typedef struct { int i; } T;
-int get8148(void);
+
+int issue8148Callback(T*);
+
+static int get() {
+	T t;
+	t.i = 42;
+	return issue8148Callback(&t);
+}
 */
 import "C"

@@ -20,5 +27,5 @@ func issue8148Callback(t *C.T) C.int {
 }

 func Issue8148() int {
-	return int(C.get8148())
+	return int(C.get())
 }
--- a/misc/cgo/test/pkg_test.go
+++ b/misc/cgo/test/pkg_test.go
@@ -5,6 +5,7 @@
 package cgotest

 import (
+	"io/ioutil"
 	"os"
 	"os/exec"
 	"path/filepath"
@@ -36,7 +37,7 @@ func TestCrossPackageTests(t *testing.T) {
 		}
 	}

-	GOPATH, err := os.MkdirTemp("", "cgotest")
+	GOPATH, err := ioutil.TempDir("", "cgotest")
 	if err != nil {
 		t.Fatal(err)
 	}
@@ -46,7 +47,7 @@ func TestCrossPackageTests(t *testing.T) {
 	if err := overlayDir(modRoot, "testdata"); err != nil {
 		t.Fatal(err)
 	}
-	if err := os.WriteFile(filepath.Join(modRoot, "go.mod"), []byte("module cgotest\n"), 0666); err != nil {
+	if err := ioutil.WriteFile(filepath.Join(modRoot, "go.mod"), []byte("module cgotest\n"), 0666); err != nil {
 		t.Fatal(err)
 	}

--- a/misc/cgo/test/setgid_linux.go
+++ b/misc/cgo/test/setgid_linux.go
@@ -2,7 +2,7 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.

-// Test that setgid does not hang on Linux.
+// Test that setgid does not hang on GNU/Linux.
 // See https://golang.org/issue/3871 for details.

 package cgotest
--- a/misc/cgo/test/test.go
+++ b/misc/cgo/test/test.go
@@ -899,10 +899,6 @@ static uint16_t issue31093F(uint16_t v) { return v; }
 // issue 32579
 typedef struct S32579 { unsigned char data[1]; } S32579;

-// issue 37033, cgo.Handle
-extern void GoFunc37033(uintptr_t handle);
-void cFunc37033(uintptr_t handle) { GoFunc37033(handle); }
-
 // issue 38649
 // Test that #define'd type aliases work.
 #define netbsd_gid unsigned int
@@ -912,9 +908,6 @@ void cFunc37033(uintptr_t handle) { GoFunc37033(handle); }
 enum Enum40494 { X_40494 };
 union Union40494 { int x; };
 void issue40494(enum Enum40494 e, union Union40494* up) {}
-
-// Issue 45451, bad handling of go:notinheap types.
-typedef struct issue45451Undefined issue45451;
 */
 import "C"

@@ -927,7 +920,6 @@ import (
 	"os/signal"
 	"reflect"
 	"runtime"
-	"runtime/cgo"
 	"sync"
 	"syscall"
 	"testing"
@@ -2238,23 +2230,6 @@ func test32579(t *testing.T) {
 	}
 }

-// issue 37033, check if cgo.Handle works properly
-
-func testHandle(t *testing.T) {
-	ch := make(chan int)
-
-	for i := 0; i < 42; i++ {
-		h := cgo.NewHandle(ch)
-		go func() {
-			C.cFunc37033(C.uintptr_t(h))
-		}()
-		if v := <-ch; issue37033 != v {
-			t.Fatalf("unexpected receiving value: got %d, want %d", v, issue37033)
-		}
-		h.Delete()
-	}
-}
-
 // issue 38649

 var issue38649 C.netbsd_gid = 42
@@ -2269,19 +2244,3 @@ var issue39877 *C.void = nil
 func Issue40494() {
 	C.issue40494(C.enum_Enum40494(C.X_40494), (*C.union_Union40494)(nil))
 }
-
-// Issue 45451.
-func test45451(t *testing.T) {
-	var u *C.issue45451
-	typ := reflect.ValueOf(u).Type().Elem()
-
-	// The type is undefined in C so allocating it should panic.
-	defer func() {
-		if r := recover(); r == nil {
-			t.Error("expected panic")
-		}
-	}()
-
-	_ = reflect.New(typ)
-	t.Errorf("reflect.New(%v) should have panicked", typ)
-}
--- a/misc/cgo/test/testdata/issue9400/asm_386.s
+++ b/misc/cgo/test/testdata/issue9400/asm_386.s
@@ -2,7 +2,7 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.

-// +build gc
+// +build !gccgo

 #include "textflag.h"

--- a/misc/cgo/test/testdata/issue9400/asm_amd64x.s
+++ b/misc/cgo/test/testdata/issue9400/asm_amd64x.s
@@ -3,7 +3,7 @@
 // license that can be found in the LICENSE file.

 // +build amd64 amd64p32
-// +build gc
+// +build !gccgo

 #include "textflag.h"

--- a/misc/cgo/test/testdata/issue9400/asm_arm.s
+++ b/misc/cgo/test/testdata/issue9400/asm_arm.s
@@ -2,7 +2,7 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.

-// +build gc
+// +build !gccgo

 #include "textflag.h"

--- a/misc/cgo/test/testdata/issue9400/asm_arm64.s
+++ b/misc/cgo/test/testdata/issue9400/asm_arm64.s
@@ -2,7 +2,7 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.

-// +build gc
+// +build !gccgo

 #include "textflag.h"

--- a/misc/cgo/test/testdata/issue9400/asm_mips64x.s
+++ b/misc/cgo/test/testdata/issue9400/asm_mips64x.s
@@ -3,7 +3,7 @@
 // license that can be found in the LICENSE file.

 // +build mips64 mips64le
-// +build gc
+// +build !gccgo

 #include "textflag.h"

--- a/misc/cgo/test/testdata/issue9400/asm_mipsx.s
+++ b/misc/cgo/test/testdata/issue9400/asm_mipsx.s
@@ -3,7 +3,7 @@
 // license that can be found in the LICENSE file.

 // +build mips mipsle
-// +build gc
+// +build !gccgo

 #include "textflag.h"

--- a/misc/cgo/test/testdata/issue9400/asm_ppc64x.s
+++ b/misc/cgo/test/testdata/issue9400/asm_ppc64x.s
@@ -3,7 +3,7 @@
 // license that can be found in the LICENSE file.

 // +build ppc64 ppc64le
-// +build gc
+// +build !gccgo

 #include "textflag.h"

--- a/misc/cgo/test/testdata/issue9400/asm_riscv64.s
+++ b/misc/cgo/test/testdata/issue9400/asm_riscv64.s
@@ -3,7 +3,7 @@
 // license that can be found in the LICENSE file.

 // +build riscv64
-// +build gc
+// +build !gccgo

 #include "textflag.h"

--- a/misc/cgo/test/testdata/issue9400/asm_s390x.s
+++ b/misc/cgo/test/testdata/issue9400/asm_s390x.s
@@ -2,7 +2,7 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.

-// +build gc
+// +build !gccgo

 #include "textflag.h"

--- a/misc/cgo/test/testx.c
+++ b/misc/cgo/test/testx.c
@@ -1,24 +0,0 @@
-// Copyright 2021 The Go Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style
-// license that can be found in the LICENSE file.
-
-#include "_cgo_export.h"
-
-void lockOSThreadC(void) {
-	lockOSThreadCallback();
-}
-
-void issue7978c(uint32_t *sync) {
-	while(__atomic_load_n(sync, __ATOMIC_SEQ_CST) != 0)
-		;
-	__atomic_add_fetch(sync, 1, __ATOMIC_SEQ_CST);
-	while(__atomic_load_n(sync, __ATOMIC_SEQ_CST) != 2)
-		;
-	issue7978cb();
-	__atomic_add_fetch(sync, 1, __ATOMIC_SEQ_CST);
-	while(__atomic_load_n(sync, __ATOMIC_SEQ_CST) != 6)
-		;
-}
-
-void f7665(void) {
-}
--- a/misc/cgo/test/testx.go
+++ b/misc/cgo/test/testx.go
@@ -12,7 +12,6 @@ package cgotest

 import (
 	"runtime"
-	"runtime/cgo"
 	"runtime/debug"
 	"strings"
 	"sync"
@@ -27,6 +26,7 @@ import (
 extern void doAdd(int, int);

 // issue 1328
+extern void BackIntoGo(void);
 void IntoC(void);

 // issue 1560
@@ -38,7 +38,11 @@ long long mysleep(int seconds);
 long long twoSleep(int);

 // issue 3775
-void lockOSThreadC(void);
+void lockOSThreadCallback(void);
+inline static void lockOSThreadC(void)
+{
+        lockOSThreadCallback();
+}
 int usleep(unsigned usec);

 // issue 4054 part 2 - part 1 in test.go
@@ -77,9 +81,21 @@ extern void f7665(void);

 #include <stdint.h>

+void issue7978cb(void);
+
 // use ugly atomic variable sync since that doesn't require calling back into
 // Go code or OS dependencies
-void issue7978c(uint32_t *sync);
+static void issue7978c(uint32_t *sync) {
+	while(__atomic_load_n(sync, __ATOMIC_SEQ_CST) != 0)
+		;
+	__atomic_add_fetch(sync, 1, __ATOMIC_SEQ_CST);
+	while(__atomic_load_n(sync, __ATOMIC_SEQ_CST) != 2)
+		;
+	issue7978cb();
+	__atomic_add_fetch(sync, 1, __ATOMIC_SEQ_CST);
+	while(__atomic_load_n(sync, __ATOMIC_SEQ_CST) != 6)
+		;
+}

 // issue 8331 part 2 - part 1 in test.go
 // A typedef of an unnamed struct is the same struct when
@@ -412,6 +428,9 @@ func test6907Go(t *testing.T) {

 // issue 7665

+//export f7665
+func f7665() {}
+
 var bad7665 unsafe.Pointer = C.f7665
 var good7665 uintptr = uintptr(C.f7665)

@@ -539,17 +558,6 @@ func test31891(t *testing.T) {
 	C.callIssue31891()
 }

-// issue 37033, check if cgo.Handle works properly
-
-var issue37033 = 42
-
-//export GoFunc37033
-func GoFunc37033(handle C.uintptr_t) {
-	h := cgo.Handle(handle)
-	ch := h.Value().(chan int)
-	ch <- issue37033
-}
-
 // issue 38408
 // A typedef pointer can be used as the element type.
 // No runtime test; just make sure it compiles.
--- a/misc/cgo/testcarchive/carchive_test.go
+++ b/misc/cgo/testcarchive/carchive_test.go
@@ -10,6 +10,7 @@ import (
 	"debug/elf"
 	"flag"
 	"fmt"
+	"io/ioutil"
 	"log"
 	"os"
 	"os/exec"
@@ -52,7 +53,7 @@ func testMain(m *testing.M) int {
 	// We need a writable GOPATH in which to run the tests.
 	// Construct one in a temporary directory.
 	var err error
-	GOPATH, err = os.MkdirTemp("", "carchive_test")
+	GOPATH, err = ioutil.TempDir("", "carchive_test")
 	if err != nil {
 		log.Panic(err)
 	}
@@ -73,7 +74,7 @@ func testMain(m *testing.M) int {
 		log.Panic(err)
 	}
 	os.Setenv("PWD", modRoot)
-	if err := os.WriteFile("go.mod", []byte("module testcarchive\n"), 0666); err != nil {
+	if err := ioutil.WriteFile("go.mod", []byte("module testcarchive\n"), 0666); err != nil {
 		log.Panic(err)
 	}

@@ -175,7 +176,7 @@ func genHeader(t *testing.T, header, dir string) {
 	// The 'cgo' command generates a number of additional artifacts,
 	// but we're only interested in the header.
 	// Shunt the rest of the outputs to a temporary directory.
-	objDir, err := os.MkdirTemp(GOPATH, "_obj")
+	objDir, err := ioutil.TempDir(GOPATH, "_obj")
 	if err != nil {
 		t.Fatal(err)
 	}
@@ -251,7 +252,7 @@ var badLineRegexp = regexp.MustCompile(`(?m)^#line [0-9]+ "/.*$`)
 // the user and make the files change based on details of the location
 // of GOPATH.
 func checkLineComments(t *testing.T, hdrname string) {
-	hdr, err := os.ReadFile(hdrname)
+	hdr, err := ioutil.ReadFile(hdrname)
 	if err != nil {
 		if !os.IsNotExist(err) {
 			t.Error(err)
@@ -617,7 +618,7 @@ func TestExtar(t *testing.T) {
 		t.Fatal(err)
 	}
 	s := strings.Replace(testar, "PWD", dir, 1)
-	if err := os.WriteFile("testar", []byte(s), 0777); err != nil {
+	if err := ioutil.WriteFile("testar", []byte(s), 0777); err != nil {
 		t.Fatal(err)
 	}

@@ -775,7 +776,7 @@ func TestSIGPROF(t *testing.T) {
 // tool with -buildmode=c-archive, it passes -shared to the compiler,
 // so we override that. The go tool doesn't work this way, but Bazel
 // will likely do it in the future. And it ought to work. This test
-// was added because at one time it did not work on PPC Linux.
+// was added because at one time it did not work on PPC GNU/Linux.
 func TestCompileWithoutShared(t *testing.T) {
 	// For simplicity, reuse the signal forwarding test.
 	checkSignalForwardingTest(t)
--- a/misc/cgo/testcarchive/testdata/libgo6/sigprof.go
+++ b/misc/cgo/testcarchive/testdata/libgo6/sigprof.go
@@ -5,7 +5,7 @@
 package main

 import (
-	"io"
+	"io/ioutil"
 	"runtime/pprof"
 )

@@ -13,7 +13,7 @@ import "C"

 //export go_start_profile
 func go_start_profile() {
-	pprof.StartCPUProfile(io.Discard)
+	pprof.StartCPUProfile(ioutil.Discard)
 }

 //export go_stop_profile
--- a/misc/cgo/testcarchive/testdata/main_unix.c
+++ b/misc/cgo/testcarchive/testdata/main_unix.c
@@ -36,7 +36,7 @@ int install_handler() {
 		return 2;
 	}
 	// gccgo does not set SA_ONSTACK for SIGSEGV.
-	if (getenv("GCCGO") == NULL && (osa.sa_flags&SA_ONSTACK) == 0) {
+	if (getenv("GCCGO") == "" && (osa.sa_flags&SA_ONSTACK) == 0) {
 		fprintf(stderr, "Go runtime did not install signal handler\n");
 		return 2;
 	}
--- a/misc/cgo/testcshared/cshared_test.go
+++ b/misc/cgo/testcshared/cshared_test.go
@@ -11,6 +11,7 @@ import (
 	"encoding/binary"
 	"flag"
 	"fmt"
+	"io/ioutil"
 	"log"
 	"os"
 	"os/exec"
@@ -124,7 +125,7 @@ func testMain(m *testing.M) int {
 	// Copy testdata into GOPATH/src/testcshared, along with a go.mod file
 	// declaring the same path.

-	GOPATH, err := os.MkdirTemp("", "cshared_test")
+	GOPATH, err := ioutil.TempDir("", "cshared_test")
 	if err != nil {
 		log.Panic(err)
 	}
@@ -139,7 +140,7 @@ func testMain(m *testing.M) int {
 		log.Panic(err)
 	}
 	os.Setenv("PWD", modRoot)
-	if err := os.WriteFile("go.mod", []byte("module testcshared\n"), 0666); err != nil {
+	if err := ioutil.WriteFile("go.mod", []byte("module testcshared\n"), 0666); err != nil {
 		log.Panic(err)
 	}

@@ -259,7 +260,7 @@ func createHeaders() error {
 	// The 'cgo' command generates a number of additional artifacts,
 	// but we're only interested in the header.
 	// Shunt the rest of the outputs to a temporary directory.
-	objDir, err := os.MkdirTemp("", "testcshared_obj")
+	objDir, err := ioutil.TempDir("", "testcshared_obj")
 	if err != nil {
 		return err
 	}
@@ -292,60 +293,11 @@ func createHeaders() error {
 		"-installsuffix", "testcshared",
 		"-o", libgoname,
 		filepath.Join(".", "libgo", "libgo.go")}
-	if GOOS == "windows" && strings.HasSuffix(args[6], ".a") {
-		args[6] = strings.TrimSuffix(args[6], ".a") + ".dll"
-	}
 	cmd = exec.Command(args[0], args[1:]...)
 	out, err = cmd.CombinedOutput()
 	if err != nil {
 		return fmt.Errorf("command failed: %v\n%v\n%s\n", args, err, out)
 	}
-	if GOOS == "windows" {
-		// We can't simply pass -Wl,--out-implib, because this relies on having imports from multiple packages,
-		// which results in the linkers output implib getting overwritten at each step. So instead build the
-		// import library the traditional way, using a def file.
-		err = os.WriteFile("libgo.def",
-			[]byte("LIBRARY libgo.dll\nEXPORTS\n\tDidInitRun\n\tDidMainRun\n\tDivu\n\tFromPkg\n\t_cgo_dummy_export\n"),
-			0644)
-		if err != nil {
-			return fmt.Errorf("unable to write def file: %v", err)
-		}
-		out, err = exec.Command(cc[0], append(cc[1:], "-print-prog-name=dlltool")...).CombinedOutput()
-		if err != nil {
-			return fmt.Errorf("unable to find dlltool path: %v\n%s\n", err, out)
-		}
-		args := []string{strings.TrimSpace(string(out)), "-D", args[6], "-l", libgoname, "-d", "libgo.def"}
-
-		// This is an unfortunate workaround for https://github.com/mstorsjo/llvm-mingw/issues/205 in which
-		// we basically reimplement the contents of the dlltool.sh wrapper: https://git.io/JZFlU
-		dlltoolContents, err := os.ReadFile(args[0])
-		if err != nil {
-			return fmt.Errorf("unable to read dlltool: %v\n", err)
-		}
-		if bytes.HasPrefix(dlltoolContents, []byte("#!/bin/sh")) && bytes.Contains(dlltoolContents, []byte("llvm-dlltool")) {
-			base, name := filepath.Split(args[0])
-			args[0] = filepath.Join(base, "llvm-dlltool")
-			var machine string
-			switch strings.SplitN(name, "-", 2)[0] {
-			case "i686":
-				machine = "i386"
-			case "x86_64":
-				machine = "i386:x86-64"
-			case "armv7":
-				machine = "arm"
-			case "aarch64":
-				machine = "arm64"
-			}
-			if len(machine) > 0 {
-				args = append(args, "-m", machine)
-			}
-		}
-
-		out, err = exec.Command(args[0], args[1:]...).CombinedOutput()
-		if err != nil {
-			return fmt.Errorf("unable to run dlltool to create import library: %v\n%s\n", err, out)
-		}
-	}

 	if runtime.GOOS != GOOS && GOOS == "android" {
 		args = append(adbCmd(), "push", libgoname, fmt.Sprintf("%s/%s", androiddir, libgoname))
@@ -429,7 +381,7 @@ func main() {

 	srcfile := filepath.Join(tmpdir, "test.go")
 	objfile := filepath.Join(tmpdir, "test.dll")
-	if err := os.WriteFile(srcfile, []byte(prog), 0666); err != nil {
+	if err := ioutil.WriteFile(srcfile, []byte(prog), 0666); err != nil {
 		t.Fatal(err)
 	}
 	argv := []string{"build", "-buildmode=c-shared"}
@@ -449,7 +401,7 @@ func main() {
 	defer f.Close()
 	section := f.Section(".edata")
 	if section == nil {
-		t.Skip(".edata section is not present")
+		t.Fatalf(".edata section is not present")
 	}

 	// TODO: deduplicate this struct from cmd/link/internal/ld/pe.go
@@ -691,7 +643,7 @@ func TestPIE(t *testing.T) {

 // Test that installing a second time recreates the header file.
 func TestCachedInstall(t *testing.T) {
-	tmpdir, err := os.MkdirTemp("", "cshared")
+	tmpdir, err := ioutil.TempDir("", "cshared")
 	if err != nil {
 		t.Fatal(err)
 	}
@@ -767,14 +719,14 @@ func TestCachedInstall(t *testing.T) {
 // copyFile copies src to dst.
 func copyFile(t *testing.T, dst, src string) {
 	t.Helper()
-	data, err := os.ReadFile(src)
+	data, err := ioutil.ReadFile(src)
 	if err != nil {
 		t.Fatal(err)
 	}
 	if err := os.MkdirAll(filepath.Dir(dst), 0777); err != nil {
 		t.Fatal(err)
 	}
-	if err := os.WriteFile(dst, data, 0666); err != nil {
+	if err := ioutil.WriteFile(dst, data, 0666); err != nil {
 		t.Fatal(err)
 	}
 }
@@ -791,19 +743,14 @@ func TestGo2C2Go(t *testing.T) {

 	t.Parallel()

-	tmpdir, err := os.MkdirTemp("", "cshared-TestGo2C2Go")
+	tmpdir, err := ioutil.TempDir("", "cshared-TestGo2C2Go")
 	if err != nil {
 		t.Fatal(err)
 	}
 	defer os.RemoveAll(tmpdir)

 	lib := filepath.Join(tmpdir, "libtestgo2c2go."+libSuffix)
-	var env []string
-	if GOOS == "windows" && strings.HasSuffix(lib, ".a") {
-		env = append(env, "CGO_LDFLAGS=-Wl,--out-implib,"+lib, "CGO_LDFLAGS_ALLOW=.*")
-		lib = strings.TrimSuffix(lib, ".a") + ".dll"
-	}
-	run(t, env, "go", "build", "-buildmode=c-shared", "-o", lib, "./go2c2go/go")
+	run(t, nil, "go", "build", "-buildmode=c-shared", "-o", lib, "./go2c2go/go")

 	cgoCflags := os.Getenv("CGO_CFLAGS")
 	if cgoCflags != "" {
--- a/misc/cgo/testgodefs/testgodefs_test.go
+++ b/misc/cgo/testgodefs/testgodefs_test.go
@@ -6,6 +6,7 @@ package testgodefs

 import (
 	"bytes"
+	"io/ioutil"
 	"os"
 	"os/exec"
 	"path/filepath"
@@ -33,7 +34,7 @@ func TestGoDefs(t *testing.T) {
 		t.Fatal(err)
 	}

-	gopath, err := os.MkdirTemp("", "testgodefs-gopath")
+	gopath, err := ioutil.TempDir("", "testgodefs-gopath")
 	if err != nil {
 		t.Fatal(err)
 	}
@@ -57,20 +58,20 @@ func TestGoDefs(t *testing.T) {
 			t.Fatalf("%s: %v\n%s", strings.Join(cmd.Args, " "), err, cmd.Stderr)
 		}

-		if err := os.WriteFile(filepath.Join(dir, fp+"_defs.go"), out, 0644); err != nil {
+		if err := ioutil.WriteFile(filepath.Join(dir, fp+"_defs.go"), out, 0644); err != nil {
 			t.Fatal(err)
 		}
 	}

-	main, err := os.ReadFile(filepath.Join("testdata", "main.go"))
+	main, err := ioutil.ReadFile(filepath.Join("testdata", "main.go"))
 	if err != nil {
 		t.Fatal(err)
 	}
-	if err := os.WriteFile(filepath.Join(dir, "main.go"), main, 0644); err != nil {
+	if err := ioutil.WriteFile(filepath.Join(dir, "main.go"), main, 0644); err != nil {
 		t.Fatal(err)
 	}

-	if err := os.WriteFile(filepath.Join(dir, "go.mod"), []byte("module testgodefs\ngo 1.14\n"), 0644); err != nil {
+	if err := ioutil.WriteFile(filepath.Join(dir, "go.mod"), []byte("module testgodefs\ngo 1.14\n"), 0644); err != nil {
 		t.Fatal(err)
 	}

--- a/misc/cgo/testplugin/plugin_test.go
+++ b/misc/cgo/testplugin/plugin_test.go
@@ -9,6 +9,7 @@ import (
 	"context"
 	"flag"
 	"fmt"
+	"io/ioutil"
 	"log"
 	"os"
 	"os/exec"
@@ -30,28 +31,15 @@ func TestMain(m *testing.M) {
 	os.Exit(testMain(m))
 }

-// tmpDir is used to cleanup logged commands -- s/tmpDir/$TMPDIR/
-var tmpDir string
-
-// prettyPrintf prints lines with tmpDir sanitized.
-func prettyPrintf(format string, args ...interface{}) {
-	s := fmt.Sprintf(format, args...)
-	if tmpDir != "" {
-		s = strings.ReplaceAll(s, tmpDir, "$TMPDIR")
-	}
-	fmt.Print(s)
-}
-
 func testMain(m *testing.M) int {
 	// Copy testdata into GOPATH/src/testplugin, along with a go.mod file
 	// declaring the same path.

-	GOPATH, err := os.MkdirTemp("", "plugin_test")
+	GOPATH, err := ioutil.TempDir("", "plugin_test")
 	if err != nil {
 		log.Panic(err)
 	}
 	defer os.RemoveAll(GOPATH)
-	tmpDir = GOPATH

 	modRoot := filepath.Join(GOPATH, "src", "testplugin")
 	altRoot := filepath.Join(GOPATH, "alt", "src", "testplugin")
@@ -62,20 +50,14 @@ func testMain(m *testing.M) int {
 		if err := overlayDir(dstRoot, srcRoot); err != nil {
 			log.Panic(err)
 		}
-		prettyPrintf("mkdir -p %s\n", dstRoot)
-		prettyPrintf("rsync -a %s/ %s\n", srcRoot, dstRoot)
-
-		if err := os.WriteFile(filepath.Join(dstRoot, "go.mod"), []byte("module testplugin\n"), 0666); err != nil {
+		if err := ioutil.WriteFile(filepath.Join(dstRoot, "go.mod"), []byte("module testplugin\n"), 0666); err != nil {
 			log.Panic(err)
 		}
-		prettyPrintf("echo 'module testplugin' > %s/go.mod\n", dstRoot)
 	}

 	os.Setenv("GOPATH", filepath.Join(GOPATH, "alt"))
 	if err := os.Chdir(altRoot); err != nil {
 		log.Panic(err)
-	} else {
-		prettyPrintf("cd %s\n", altRoot)
 	}
 	os.Setenv("PWD", altRoot)
 	goCmd(nil, "build", "-buildmode=plugin", "-o", filepath.Join(modRoot, "plugin-mismatch.so"), "./plugin-mismatch")
@@ -83,8 +65,6 @@ func testMain(m *testing.M) int {
 	os.Setenv("GOPATH", GOPATH)
 	if err := os.Chdir(modRoot); err != nil {
 		log.Panic(err)
-	} else {
-		prettyPrintf("cd %s\n", modRoot)
 	}
 	os.Setenv("PWD", modRoot)

@@ -92,14 +72,13 @@ func testMain(m *testing.M) int {

 	goCmd(nil, "build", "-buildmode=plugin", "./plugin1")
 	goCmd(nil, "build", "-buildmode=plugin", "./plugin2")
-	so, err := os.ReadFile("plugin2.so")
+	so, err := ioutil.ReadFile("plugin2.so")
 	if err != nil {
 		log.Panic(err)
 	}
-	if err := os.WriteFile("plugin2-dup.so", so, 0444); err != nil {
+	if err := ioutil.WriteFile("plugin2-dup.so", so, 0444); err != nil {
 		log.Panic(err)
 	}
-	prettyPrintf("cp plugin2.so plugin2-dup.so\n")

 	goCmd(nil, "build", "-buildmode=plugin", "-o=sub/plugin1.so", "./sub/plugin1")
 	goCmd(nil, "build", "-buildmode=plugin", "-o=unnamed1.so", "./unnamed1/main.go")
@@ -116,53 +95,8 @@ func goCmd(t *testing.T, op string, args ...string) {
 	run(t, "go", append([]string{op, "-gcflags", gcflags}, args...)...)
 }

-// escape converts a string to something suitable for a shell command line.
-func escape(s string) string {
-	s = strings.Replace(s, "\\", "\\\\", -1)
-	s = strings.Replace(s, "'", "\\'", -1)
-	// Conservative guess at characters that will force quoting
-	if s == "" || strings.ContainsAny(s, "\\ ;#*&$~?!|[]()<>{}`") {
-		s = "'" + s + "'"
-	}
-	return s
-}
-
-// asCommandLine renders cmd as something that could be copy-and-pasted into a command line
-func asCommandLine(cwd string, cmd *exec.Cmd) string {
-	s := "("
-	if cmd.Dir != "" && cmd.Dir != cwd {
-		s += "cd" + escape(cmd.Dir) + ";"
-	}
-	for _, e := range cmd.Env {
-		if !strings.HasPrefix(e, "PATH=") &&
-			!strings.HasPrefix(e, "HOME=") &&
-			!strings.HasPrefix(e, "USER=") &&
-			!strings.HasPrefix(e, "SHELL=") {
-			s += " "
-			s += escape(e)
-		}
-	}
-	// These EVs are relevant to this test.
-	for _, e := range os.Environ() {
-		if strings.HasPrefix(e, "PWD=") ||
-			strings.HasPrefix(e, "GOPATH=") ||
-			strings.HasPrefix(e, "LD_LIBRARY_PATH=") {
-			s += " "
-			s += escape(e)
-		}
-	}
-	for _, a := range cmd.Args {
-		s += " "
-		s += escape(a)
-	}
-	s += " )"
-	return s
-}
-
 func run(t *testing.T, bin string, args ...string) string {
 	cmd := exec.Command(bin, args...)
-	cmdLine := asCommandLine(".", cmd)
-	prettyPrintf("%s\n", cmdLine)
 	cmd.Stderr = new(strings.Builder)
 	out, err := cmd.Output()
 	if err != nil {
@@ -263,33 +197,16 @@ func TestIssue25756(t *testing.T) {
 	}
 }

-// Test with main using -buildmode=pie with plugin for issue #43228
-func TestIssue25756pie(t *testing.T) {
-	if os.Getenv("GO_BUILDER_NAME") == "darwin-arm64-11_0-toothrot" {
-		t.Skip("broken on darwin/arm64 builder in sharded mode; see issue 46239")
-	}
-
-	goCmd(t, "build", "-buildmode=plugin", "-o", "life.so", "./issue25756/plugin")
-	goCmd(t, "build", "-buildmode=pie", "-o", "issue25756pie.exe", "./issue25756/main.go")
-	run(t, "./issue25756pie.exe")
-}
-
 func TestMethod(t *testing.T) {
 	// Exported symbol's method must be live.
 	goCmd(t, "build", "-buildmode=plugin", "-o", "plugin.so", "./method/plugin.go")
 	goCmd(t, "build", "-o", "method.exe", "./method/main.go")
-	run(t, "./method.exe")
-}

-func TestMethod2(t *testing.T) {
-	goCmd(t, "build", "-buildmode=plugin", "-o", "method2.so", "./method2/plugin.go")
-	goCmd(t, "build", "-o", "method2.exe", "./method2/main.go")
-	run(t, "./method2.exe")
-}
-
-func TestIssue44956(t *testing.T) {
-	goCmd(t, "build", "-buildmode=plugin", "-o", "issue44956p1.so", "./issue44956/plugin1.go")
-	goCmd(t, "build", "-buildmode=plugin", "-o", "issue44956p2.so", "./issue44956/plugin2.go")
-	goCmd(t, "build", "-o", "issue44956.exe", "./issue44956/main.go")
-	run(t, "./issue44956.exe")
+	ctx, cancel := context.WithTimeout(context.Background(), 10*time.Second)
+	defer cancel()
+	cmd := exec.CommandContext(ctx, "./method.exe")
+	out, err := cmd.CombinedOutput()
+	if err != nil {
+		t.Fatalf("%s: %v\n%s", strings.Join(cmd.Args, " "), err, out)
+	}
 }
--- a/misc/cgo/testplugin/testdata/issue44956/base/base.go
+++ b/misc/cgo/testplugin/testdata/issue44956/base/base.go
@@ -1,7 +0,0 @@
-// Copyright 2021 The Go Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style
-// license that can be found in the LICENSE file.
-
-package base
-
-var X = &map[int]int{123: 456}
--- a/misc/cgo/testplugin/testdata/issue44956/main.go
+++ b/misc/cgo/testplugin/testdata/issue44956/main.go
@@ -1,47 +0,0 @@
-// Copyright 2021 The Go Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style
-// license that can be found in the LICENSE file.
-
-// Issue 44956: writable static temp is not exported correctly.
-// In the test below, package base is
-//
-//     X = &map{...}
-//
-// which compiles to
-//
-//     X = &stmp           // static
-//     stmp = makemap(...) // in init function
-//
-// plugin1 and plugin2 both import base. plugin1 doesn't use
-// base.X, so that symbol is deadcoded in plugin1.
-//
-// plugin1 is loaded first. base.init runs at that point, which
-// initialize base.stmp.
-//
-// plugin2 is then loaded. base.init already ran, so it doesn't run
-// again. When base.stmp is not exported, plugin2's base.X points to
-// its own private base.stmp, which is not initialized, fail.
-
-package main
-
-import "plugin"
-
-func main() {
-	_, err := plugin.Open("issue44956p1.so")
-	if err != nil {
-		panic("FAIL")
-	}
-
-	p2, err := plugin.Open("issue44956p2.so")
-	if err != nil {
-		panic("FAIL")
-	}
-	f, err := p2.Lookup("F")
-	if err != nil {
-		panic("FAIL")
-	}
-	x := f.(func() *map[int]int)()
-	if x == nil || (*x)[123] != 456 {
-		panic("FAIL")
-	}
-}
--- a/misc/cgo/testplugin/testdata/issue44956/plugin1.go
+++ b/misc/cgo/testplugin/testdata/issue44956/plugin1.go
@@ -1,9 +0,0 @@
-// Copyright 2021 The Go Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style
-// license that can be found in the LICENSE file.
-
-package main
-
-import _ "testplugin/issue44956/base"
-
-func main() {}
--- a/misc/cgo/testplugin/testdata/issue44956/plugin2.go
+++ b/misc/cgo/testplugin/testdata/issue44956/plugin2.go
@@ -1,11 +0,0 @@
-// Copyright 2021 The Go Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style
-// license that can be found in the LICENSE file.
-
-package main
-
-import "testplugin/issue44956/base"
-
-func F() *map[int]int { return base.X }
-
-func main() {}
--- a/misc/cgo/testplugin/testdata/method2/main.go
+++ b/misc/cgo/testplugin/testdata/method2/main.go
@@ -1,32 +0,0 @@
-// Copyright 2021 The Go Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style
-// license that can be found in the LICENSE file.
-
-// A type can be passed to a plugin and converted to interface
-// there. So its methods need to be live.
-
-package main
-
-import (
-	"plugin"
-
-	"testplugin/method2/p"
-)
-
-var t p.T
-
-type I interface{ M() }
-
-func main() {
-	pl, err := plugin.Open("method2.so")
-	if err != nil {
-		panic(err)
-	}
-
-	f, err := pl.Lookup("F")
-	if err != nil {
-		panic(err)
-	}
-
-	f.(func(p.T) interface{})(t).(I).M()
-}
--- a/misc/cgo/testplugin/testdata/method2/p/p.go
+++ b/misc/cgo/testplugin/testdata/method2/p/p.go
@@ -1,9 +0,0 @@
-// Copyright 2021 The Go Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style
-// license that can be found in the LICENSE file.
-
-package p
-
-type T int
-
-func (T) M() { println("M") }
--- a/misc/cgo/testplugin/testdata/method2/plugin.go
+++ b/misc/cgo/testplugin/testdata/method2/plugin.go
@@ -1,11 +0,0 @@
-// Copyright 2021 The Go Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style
-// license that can be found in the LICENSE file.
-
-package main
-
-import "testplugin/method2/p"
-
-func main() {}
-
-func F(t p.T) interface{} { return t }
--- a/misc/cgo/testsanitizers/cc_test.go
+++ b/misc/cgo/testsanitizers/cc_test.go
@@ -11,6 +11,7 @@ import (
 	"encoding/json"
 	"errors"
 	"fmt"
+	"io/ioutil"
 	"os"
 	"os/exec"
 	"path/filepath"
@@ -35,7 +36,7 @@ func requireOvercommit(t *testing.T) {

 	overcommit.Once.Do(func() {
 		var out []byte
-		out, overcommit.err = os.ReadFile("/proc/sys/vm/overcommit_memory")
+		out, overcommit.err = ioutil.ReadFile("/proc/sys/vm/overcommit_memory")
 		if overcommit.err != nil {
 			return
 		}
@@ -312,14 +313,14 @@ int main() {
 `)

 func (c *config) checkCSanitizer() (skip bool, err error) {
-	dir, err := os.MkdirTemp("", c.sanitizer)
+	dir, err := ioutil.TempDir("", c.sanitizer)
 	if err != nil {
 		return false, fmt.Errorf("failed to create temp directory: %v", err)
 	}
 	defer os.RemoveAll(dir)

 	src := filepath.Join(dir, "return0.c")
-	if err := os.WriteFile(src, cMain, 0600); err != nil {
+	if err := ioutil.WriteFile(src, cMain, 0600); err != nil {
 		return false, fmt.Errorf("failed to write C source file: %v", err)
 	}

@@ -417,7 +418,7 @@ func (d *tempDir) Join(name string) string {

 func newTempDir(t *testing.T) *tempDir {
 	t.Helper()
-	dir, err := os.MkdirTemp("", filepath.Dir(t.Name()))
+	dir, err := ioutil.TempDir("", filepath.Dir(t.Name()))
 	if err != nil {
 		t.Fatalf("Failed to create temp dir: %v", err)
 	}
@@ -439,14 +440,3 @@ func hangProneCmd(name string, arg ...string) *exec.Cmd {
 	}
 	return cmd
 }
-
-// mSanSupported is a copy of the function cmd/internal/sys.MSanSupported,
-// because the internal pacakage can't be used here.
-func mSanSupported(goos, goarch string) bool {
-	switch goos {
-	case "linux":
-		return goarch == "amd64" || goarch == "arm64"
-	default:
-		return false
-	}
-}
--- a/misc/cgo/testsanitizers/cshared_test.go
+++ b/misc/cgo/testsanitizers/cshared_test.go
@@ -6,7 +6,7 @@ package sanitizers_test

 import (
 	"fmt"
-	"os"
+	"io/ioutil"
 	"strings"
 	"testing"
 )
@@ -19,12 +19,6 @@ func TestShared(t *testing.T) {
 	if err != nil {
 		t.Fatal(err)
 	}
-
-	GOARCH, err := goEnv("GOARCH")
-	if err != nil {
-		t.Fatal(err)
-	}
-
 	libExt := "so"
 	if GOOS == "darwin" {
 		libExt = "dylib"
@@ -47,11 +41,6 @@ func TestShared(t *testing.T) {
 	for _, tc := range cases {
 		tc := tc
 		name := strings.TrimSuffix(tc.src, ".go")
-		//The memory sanitizer tests require support for the -msan option.
-		if tc.sanitizer == "memory" && !mSanSupported(GOOS, GOARCH) {
-			t.Logf("skipping %s test on %s/%s; -msan option is not supported.", name, GOOS, GOARCH)
-			continue
-		}
 		t.Run(name, func(t *testing.T) {
 			t.Parallel()
 			config := configure(tc.sanitizer)
@@ -64,7 +53,7 @@ func TestShared(t *testing.T) {
 			mustRun(t, config.goCmd("build", "-buildmode=c-shared", "-o", lib, srcPath(tc.src)))

 			cSrc := dir.Join("main.c")
-			if err := os.WriteFile(cSrc, cMain, 0600); err != nil {
+			if err := ioutil.WriteFile(cSrc, cMain, 0600); err != nil {
 				t.Fatalf("failed to write C source file: %v", err)
 			}

--- a/misc/cgo/testsanitizers/msan_test.go
+++ b/misc/cgo/testsanitizers/msan_test.go
@@ -10,19 +10,6 @@ import (
 )

 func TestMSAN(t *testing.T) {
-	goos, err := goEnv("GOOS")
-	if err != nil {
-		t.Fatal(err)
-	}
-	goarch, err := goEnv("GOARCH")
-	if err != nil {
-		t.Fatal(err)
-	}
-	// The msan tests require support for the -msan option.
-	if !mSanSupported(goos, goarch) {
-		t.Skipf("skipping on %s/%s; -msan option is not supported.", goos, goarch)
-	}
-
 	t.Parallel()
 	requireOvercommit(t)
 	config := configure("memory")
@@ -42,7 +29,6 @@ func TestMSAN(t *testing.T) {
 		{src: "msan5.go"},
 		{src: "msan6.go"},
 		{src: "msan7.go"},
-		{src: "msan8.go"},
 		{src: "msan_fail.go", wantErr: true},
 	}
 	for _, tc := range cases {
--- a/misc/cgo/testsanitizers/testdata/msan8.go
+++ b/misc/cgo/testsanitizers/testdata/msan8.go
@@ -1,109 +0,0 @@
-// Copyright 2021 The Go Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style
-// license that can be found in the LICENSE file.
-
-package main
-
-/*
-#include <pthread.h>
-#include <signal.h>
-#include <stdint.h>
-
-#include <sanitizer/msan_interface.h>
-
-// cgoTracebackArg is the type of the argument passed to msanGoTraceback.
-struct cgoTracebackArg {
-	uintptr_t context;
-	uintptr_t sigContext;
-	uintptr_t* buf;
-	uintptr_t max;
-};
-
-// msanGoTraceback is registered as the cgo traceback function.
-// This will be called when a signal occurs.
-void msanGoTraceback(void* parg) {
-	struct cgoTracebackArg* arg = (struct cgoTracebackArg*)(parg);
-        arg->buf[0] = 0;
-}
-
-// msanGoWait will be called with all registers undefined as far as
-// msan is concerned. It just waits for a signal.
-// Because the registers are msan-undefined, the signal handler will
-// be invoked with all registers msan-undefined.
-__attribute__((noinline))
-void msanGoWait(unsigned long a1, unsigned long a2, unsigned long a3, unsigned long a4, unsigned long a5, unsigned long a6) {
-	sigset_t mask;
-
-	sigemptyset(&mask);
-        sigsuspend(&mask);
-}
-
-// msanGoSignalThread is the thread ID of the msanGoLoop thread.
-static pthread_t msanGoSignalThread;
-
-// msanGoSignalThreadSet is used to record that msanGoSignalThread
-// has been initialized. This is accessed atomically.
-static int32_t msanGoSignalThreadSet;
-
-// uninit is explicitly poisoned, so that we can make all registers
-// undefined by calling msanGoWait.
-static unsigned long uninit;
-
-// msanGoLoop loops calling msanGoWait, with the arguments passed
-// such that msan thinks that they are undefined. msan permits
-// undefined values to be used as long as they are not used to
-// for conditionals or for memory access.
-void msanGoLoop() {
-	int i;
-
-	msanGoSignalThread = pthread_self();
-        __atomic_store_n(&msanGoSignalThreadSet, 1, __ATOMIC_SEQ_CST);
-
-	// Force uninit to be undefined for msan.
-	__msan_poison(&uninit, sizeof uninit);
-	for (i = 0; i < 100; i++) {
-		msanGoWait(uninit, uninit, uninit, uninit, uninit, uninit);
-        }
-}
-
-// msanGoReady returns whether msanGoSignalThread is set.
-int msanGoReady() {
-	return __atomic_load_n(&msanGoSignalThreadSet, __ATOMIC_SEQ_CST) != 0;
-}
-
-// msanGoSendSignal sends a signal to the msanGoLoop thread.
-void msanGoSendSignal() {
-	pthread_kill(msanGoSignalThread, SIGWINCH);
-}
-*/
-import "C"
-
-import (
-	"runtime"
-	"time"
-)
-
-func main() {
-	runtime.SetCgoTraceback(0, C.msanGoTraceback, nil, nil)
-
-	c := make(chan bool)
-	go func() {
-		defer func() { c <- true }()
-		C.msanGoLoop()
-	}()
-
-	for C.msanGoReady() == 0 {
-		time.Sleep(time.Microsecond)
-	}
-
-loop:
-	for {
-		select {
-		case <-c:
-			break loop
-		default:
-			C.msanGoSendSignal()
-			time.Sleep(time.Microsecond)
-		}
-	}
-}
--- a/misc/cgo/testsanitizers/testdata/tsan9.go
+++ b/misc/cgo/testsanitizers/testdata/tsan9.go
@@ -44,7 +44,7 @@ void spin() {
 import "C"

 import (
-	"io"
+	"io/ioutil"
 	"runtime/pprof"
 	"time"
 )
@@ -60,7 +60,7 @@ func goSpin() {
 }

 func main() {
-	pprof.StartCPUProfile(io.Discard)
+	pprof.StartCPUProfile(ioutil.Discard)
 	go C.spin()
 	goSpin()
 	pprof.StopCPUProfile()
--- a/misc/cgo/testshared/shared_test.go
+++ b/misc/cgo/testshared/shared_test.go
@@ -13,6 +13,7 @@ import (
 	"fmt"
 	"go/build"
 	"io"
+	"io/ioutil"
 	"log"
 	"os"
 	"os/exec"
@@ -89,7 +90,7 @@ func goCmd(t *testing.T, args ...string) string {

 // TestMain calls testMain so that the latter can use defer (TestMain exits with os.Exit).
 func testMain(m *testing.M) (int, error) {
-	workDir, err := os.MkdirTemp("", "shared_test")
+	workDir, err := ioutil.TempDir("", "shared_test")
 	if err != nil {
 		return 0, err
 	}
@@ -176,7 +177,7 @@ func cloneTestdataModule(gopath string) (string, error) {
 	if err := overlayDir(modRoot, "testdata"); err != nil {
 		return "", err
 	}
-	if err := os.WriteFile(filepath.Join(modRoot, "go.mod"), []byte("module testshared\n"), 0644); err != nil {
+	if err := ioutil.WriteFile(filepath.Join(modRoot, "go.mod"), []byte("module testshared\n"), 0644); err != nil {
 		return "", err
 	}
 	return modRoot, nil
@@ -317,7 +318,7 @@ func TestShlibnameFiles(t *testing.T) {
 	}
 	for _, pkg := range pkgs {
 		shlibnamefile := filepath.Join(gorootInstallDir, pkg+".shlibname")
-		contentsb, err := os.ReadFile(shlibnamefile)
+		contentsb, err := ioutil.ReadFile(shlibnamefile)
 		if err != nil {
 			t.Errorf("error reading shlibnamefile for %s: %v", pkg, err)
 			continue
@@ -790,7 +791,7 @@ func resetFileStamps() {
 // It also sets the time of the file, so that we can see if it is rewritten.
 func touch(t *testing.T, path string) (cleanup func()) {
 	t.Helper()
-	data, err := os.ReadFile(path)
+	data, err := ioutil.ReadFile(path)
 	if err != nil {
 		t.Fatal(err)
 	}
@@ -836,14 +837,14 @@ func touch(t *testing.T, path string) (cleanup func()) {
 	// user-writable.
 	perm := fi.Mode().Perm() | 0200

-	if err := os.WriteFile(path, data, perm); err != nil {
+	if err := ioutil.WriteFile(path, data, perm); err != nil {
 		t.Fatal(err)
 	}
 	if err := os.Chtimes(path, nearlyNew, nearlyNew); err != nil {
 		t.Fatal(err)
 	}
 	return func() {
-		if err := os.WriteFile(path, old, perm); err != nil {
+		if err := ioutil.WriteFile(path, old, perm); err != nil {
 			t.Fatal(err)
 		}
 	}
--- a/misc/cgo/testshared/testdata/depBase/asm.s
+++ b/misc/cgo/testshared/testdata/depBase/asm.s
@@ -2,7 +2,7 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.

-// +build gc
+// +build !gccgo

 #include "textflag.h"

--- a/misc/cgo/testshared/testdata/depBase/stubs.go
+++ b/misc/cgo/testshared/testdata/depBase/stubs.go
@@ -2,7 +2,7 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.

-// +build gc
+// +build !gccgo

 package depBase

--- a/misc/cgo/testso/so_test.go
+++ b/misc/cgo/testso/so_test.go
@@ -7,6 +7,7 @@
 package so_test

 import (
+	"io/ioutil"
 	"log"
 	"os"
 	"os/exec"
@@ -36,7 +37,7 @@ func requireTestSOSupported(t *testing.T) {
 func TestSO(t *testing.T) {
 	requireTestSOSupported(t)

-	GOPATH, err := os.MkdirTemp("", "cgosotest")
+	GOPATH, err := ioutil.TempDir("", "cgosotest")
 	if err != nil {
 		log.Fatal(err)
 	}
@@ -46,7 +47,7 @@ func TestSO(t *testing.T) {
 	if err := overlayDir(modRoot, "testdata"); err != nil {
 		log.Panic(err)
 	}
-	if err := os.WriteFile(filepath.Join(modRoot, "go.mod"), []byte("module cgosotest\n"), 0666); err != nil {
+	if err := ioutil.WriteFile(filepath.Join(modRoot, "go.mod"), []byte("module cgosotest\n"), 0666); err != nil {
 		log.Panic(err)
 	}

@@ -79,10 +80,6 @@ func TestSO(t *testing.T) {
 	case "windows":
 		ext = "dll"
 		args = append(args, "-DEXPORT_DLL")
-		// At least in mingw-clang it is not permitted to just name a .dll
-		// on the command line. You must name the corresponding import
-		// library instead, even though the dll is used when the executable is run.
-		args = append(args, "-Wl,-out-implib,libcgosotest.a")
 	case "aix":
 		ext = "so.1"
 	}
--- a/misc/cgo/testso/testdata/cgoso.go
+++ b/misc/cgo/testso/testdata/cgoso.go
@@ -14,7 +14,7 @@ package cgosotest
 #cgo solaris LDFLAGS: -L. -lcgosotest
 #cgo netbsd LDFLAGS: -L. libcgosotest.so
 #cgo darwin LDFLAGS: -L. libcgosotest.dylib
-#cgo windows LDFLAGS: -L. libcgosotest.a
+#cgo windows LDFLAGS: -L. libcgosotest.dll
 #cgo aix LDFLAGS: -L. -l cgosotest

 void init(void);
--- a/misc/cgo/testsovar/so_test.go
+++ b/misc/cgo/testsovar/so_test.go
@@ -7,6 +7,7 @@
 package so_test

 import (
+	"io/ioutil"
 	"log"
 	"os"
 	"os/exec"
@@ -36,7 +37,7 @@ func requireTestSOSupported(t *testing.T) {
 func TestSO(t *testing.T) {
 	requireTestSOSupported(t)

-	GOPATH, err := os.MkdirTemp("", "cgosotest")
+	GOPATH, err := ioutil.TempDir("", "cgosotest")
 	if err != nil {
 		log.Fatal(err)
 	}
@@ -46,7 +47,7 @@ func TestSO(t *testing.T) {
 	if err := overlayDir(modRoot, "testdata"); err != nil {
 		log.Panic(err)
 	}
-	if err := os.WriteFile(filepath.Join(modRoot, "go.mod"), []byte("module cgosotest\n"), 0666); err != nil {
+	if err := ioutil.WriteFile(filepath.Join(modRoot, "go.mod"), []byte("module cgosotest\n"), 0666); err != nil {
 		log.Panic(err)
 	}

@@ -79,10 +80,6 @@ func TestSO(t *testing.T) {
 	case "windows":
 		ext = "dll"
 		args = append(args, "-DEXPORT_DLL")
-		// At least in mingw-clang it is not permitted to just name a .dll
-		// on the command line. You must name the corresponding import
-		// library instead, even though the dll is used when the executable is run.
-		args = append(args, "-Wl,-out-implib,libcgosotest.a")
 	case "aix":
 		ext = "so.1"
 	}
--- a/misc/cgo/testsovar/testdata/cgoso.go
+++ b/misc/cgo/testsovar/testdata/cgoso.go
@@ -18,7 +18,7 @@ package cgosotest
 #cgo solaris LDFLAGS: -L. -lcgosotest
 #cgo netbsd LDFLAGS: -L. libcgosotest.so
 #cgo darwin LDFLAGS: -L. libcgosotest.dylib
-#cgo windows LDFLAGS: -L. libcgosotest.a
+#cgo windows LDFLAGS: -L. libcgosotest.dll
 #cgo aix LDFLAGS: -L. -l cgosotest

 #include "cgoso_c.h"
--- a/misc/chrome/gophertool/popup.html
+++ b/misc/chrome/gophertool/popup.html
@@ -15,7 +15,7 @@
 <a href="#" url="https://golang.org/pkg/">pkg</a> id/name:</small>
 <form style='margin: 0' id='navform'><nobr><input id="inputbox" size=10 tabindex=1 /><input type="submit" value="go" /></nobr></form>
 <small>Also: <a href="#" url="https://build.golang.org">buildbots</a>
-<a href="#" url="https://github.com/golang/go">GitHub</a>
+<a href="#" url="https://github.com/golang/go">Github</a>
 </small>
 </body>
 </html>
--- a/misc/ios/detect.go
+++ b/misc/ios/detect.go
@@ -16,6 +16,7 @@ import (
 	"bytes"
 	"crypto/x509"
 	"fmt"
+	"io/ioutil"
 	"os"
 	"os/exec"
 	"strings"
@@ -37,7 +38,7 @@ func main() {
 	fmt.Println("# will be overwritten when running Go programs.")
 	for _, mp := range mps {
 		fmt.Println()
-		f, err := os.CreateTemp("", "go_ios_detect_")
+		f, err := ioutil.TempFile("", "go_ios_detect_")
 		check(err)
 		fname := f.Name()
 		defer os.Remove(fname)
--- a/misc/ios/go_ios_exec.go
+++ b/misc/ios/go_ios_exec.go
@@ -26,6 +26,7 @@ import (
 	"fmt"
 	"go/build"
 	"io"
+	"io/ioutil"
 	"log"
 	"net"
 	"os"
@@ -78,7 +79,7 @@ func main() {

 func runMain() (int, error) {
 	var err error
-	tmpdir, err = os.MkdirTemp("", "go_ios_exec_")
+	tmpdir, err = ioutil.TempDir("", "go_ios_exec_")
 	if err != nil {
 		return 1, err
 	}
@@ -204,13 +205,13 @@ func assembleApp(appdir, bin string) error {
 	}

 	entitlementsPath := filepath.Join(tmpdir, "Entitlements.plist")
-	if err := os.WriteFile(entitlementsPath, []byte(entitlementsPlist()), 0744); err != nil {
+	if err := ioutil.WriteFile(entitlementsPath, []byte(entitlementsPlist()), 0744); err != nil {
 		return err
 	}
-	if err := os.WriteFile(filepath.Join(appdir, "Info.plist"), []byte(infoPlist(pkgpath)), 0744); err != nil {
+	if err := ioutil.WriteFile(filepath.Join(appdir, "Info.plist"), []byte(infoPlist(pkgpath)), 0744); err != nil {
 		return err
 	}
-	if err := os.WriteFile(filepath.Join(appdir, "ResourceRules.plist"), []byte(resourceRules), 0744); err != nil {
+	if err := ioutil.WriteFile(filepath.Join(appdir, "ResourceRules.plist"), []byte(resourceRules), 0744); err != nil {
 		return err
 	}
 	return nil
--- a/misc/linkcheck/linkcheck.go
+++ b/misc/linkcheck/linkcheck.go
@@ -11,7 +11,7 @@ import (
 	"errors"
 	"flag"
 	"fmt"
-	"io"
+	"io/ioutil"
 	"log"
 	"net/http"
 	"os"
@@ -144,7 +144,7 @@ func doCrawl(url string) error {
 	if res.StatusCode != 200 {
 		return errors.New(res.Status)
 	}
-	slurp, err := io.ReadAll(res.Body)
+	slurp, err := ioutil.ReadAll(res.Body)
 	res.Body.Close()
 	if err != nil {
 		log.Fatalf("Error reading %s body: %v", url, err)
--- a/misc/reboot/experiment_toolid_test.go
+++ b/misc/reboot/experiment_toolid_test.go
@@ -13,6 +13,7 @@ package reboot_test

 import (
 	"bytes"
+	"io/ioutil"
 	"os"
 	"os/exec"
 	"path/filepath"
@@ -22,7 +23,7 @@ import (

 func TestExperimentToolID(t *testing.T) {
 	// Set up GOROOT
-	goroot, err := os.MkdirTemp("", "experiment-goroot")
+	goroot, err := ioutil.TempDir("", "experiment-goroot")
 	if err != nil {
 		t.Fatal(err)
 	}
@@ -33,13 +34,13 @@ func TestExperimentToolID(t *testing.T) {
 		t.Fatal(err)
 	}

-	if err := os.WriteFile(filepath.Join(goroot, "VERSION"), []byte("go1.999"), 0666); err != nil {
+	if err := ioutil.WriteFile(filepath.Join(goroot, "VERSION"), []byte("go1.999"), 0666); err != nil {
 		t.Fatal(err)
 	}
 	env := append(os.Environ(), "GOROOT=", "GOROOT_BOOTSTRAP="+runtime.GOROOT())

 	// Use a clean cache.
-	gocache, err := os.MkdirTemp("", "experiment-gocache")
+	gocache, err := ioutil.TempDir("", "experiment-gocache")
 	if err != nil {
 		t.Fatal(err)
 	}
--- a/misc/reboot/reboot_test.go
+++ b/misc/reboot/reboot_test.go
@@ -7,6 +7,7 @@
 package reboot_test

 import (
+	"io/ioutil"
 	"os"
 	"os/exec"
 	"path/filepath"
@@ -15,7 +16,7 @@ import (
 )

 func TestRepeatBootstrap(t *testing.T) {
-	goroot, err := os.MkdirTemp("", "reboot-goroot")
+	goroot, err := ioutil.TempDir("", "reboot-goroot")
 	if err != nil {
 		t.Fatal(err)
 	}
@@ -26,7 +27,7 @@ func TestRepeatBootstrap(t *testing.T) {
 		t.Fatal(err)
 	}

-	if err := os.WriteFile(filepath.Join(goroot, "VERSION"), []byte(runtime.Version()), 0666); err != nil {
+	if err := ioutil.WriteFile(filepath.Join(goroot, "VERSION"), []byte(runtime.Version()), 0666); err != nil {
 		t.Fatal(err)
 	}

--- a/misc/trace/trace_viewer_full.html
+++ b/misc/trace/trace_viewer_full.html
@@ -993,13 +993,13 @@
    </style>
    <div style="padding-right: 200px">
      <div style="float:right;  border-style: solid; border-width: 1px; padding:20px">
-        X no feedback<br>
-        0 uninitialized<br>
-        . premonomorphic<br>
-        1 monomorphic<br>
-        ^ recompute handler<br>
-        P polymorphic<br>
-        N megamorphic<br>
+        X no feedback<br/>
+        0 uninitialized<br/>
+        . premonomorphic<br/>
+        1 monomorphic<br/>
+        ^ recompute handler<br/>
+        P polymorphic<br/>
+        N megamorphic<br/>
        G generic
      </div>
    </div>
@@ -3596,7 +3596,7 @@
    <div id="pipeline_per_frame_container">
      <div class="subtitle">Graphics Pipeline and Raster Tasks</div>
      <div class="description">
-        When raster tasks are completed in comparison to the rest of the graphics pipeline.<br>
+        When raster tasks are completed in comparison to the rest of the graphics pipeline.<br/>
        Only pages where raster tasks are completed after beginFrame is issued are included.
      </div>
      <tr-v-ui-raster-visualization id="rasterVisualization">
--- a/misc/wasm/wasm_exec.js
+++ b/misc/wasm/wasm_exec.js
@@ -296,8 +296,8 @@
 						setInt64(sp + 8, (timeOrigin + performance.now()) * 1000000);
 					},

-					// func walltime() (sec int64, nsec int32)
-					"runtime.walltime": (sp) => {
+					// func walltime1() (sec int64, nsec int32)
+					"runtime.walltime1": (sp) => {
 						sp >>>= 0;
 						const msec = (new Date).getTime();
 						setInt64(sp + 8, msec / 1000);
@@ -401,7 +401,6 @@
 							storeValue(sp + 56, result);
 							this.mem.setUint8(sp + 64, 1);
 						} catch (err) {
-							sp = this._inst.exports.getsp() >>> 0; // see comment above
 							storeValue(sp + 56, err);
 							this.mem.setUint8(sp + 64, 0);
 						}
@@ -418,7 +417,6 @@
 							storeValue(sp + 40, result);
 							this.mem.setUint8(sp + 48, 1);
 						} catch (err) {
-							sp = this._inst.exports.getsp() >>> 0; // see comment above
 							storeValue(sp + 40, err);
 							this.mem.setUint8(sp + 48, 0);
 						}
@@ -435,7 +433,6 @@
 							storeValue(sp + 40, result);
 							this.mem.setUint8(sp + 48, 1);
 						} catch (err) {
-							sp = this._inst.exports.getsp() >>> 0; // see comment above
 							storeValue(sp + 40, err);
 							this.mem.setUint8(sp + 48, 0);
 						}
--- a/robots.txt
+++ b/robots.txt
@@ -0,0 +1,2 @@
+User-agent: *
+Disallow: /
--- a/src/archive/tar/stat_actime1.go
+++ b/src/archive/tar/stat_actime1.go
@@ -2,7 +2,6 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.

-//go:build aix || linux || dragonfly || openbsd || solaris
 // +build aix linux dragonfly openbsd solaris

 package tar
--- a/src/archive/tar/stat_actime2.go
+++ b/src/archive/tar/stat_actime2.go
@@ -2,7 +2,6 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.

-//go:build darwin || freebsd || netbsd
 // +build darwin freebsd netbsd

 package tar
--- a/src/archive/tar/stat_unix.go
+++ b/src/archive/tar/stat_unix.go
@@ -2,7 +2,6 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.

-//go:build aix || linux || darwin || dragonfly || freebsd || openbsd || netbsd || solaris
 // +build aix linux darwin dragonfly freebsd openbsd netbsd solaris

 package tar
--- a/src/archive/tar/tar_test.go
+++ b/src/archive/tar/tar_test.go
@@ -262,11 +262,16 @@ func TestFileInfoHeaderDir(t *testing.T) {
 func TestFileInfoHeaderSymlink(t *testing.T) {
 	testenv.MustHaveSymlink(t)

-	tmpdir := t.TempDir()
+	tmpdir, err := os.MkdirTemp("", "TestFileInfoHeaderSymlink")
+	if err != nil {
+		t.Fatal(err)
+	}
+	defer os.RemoveAll(tmpdir)

 	link := filepath.Join(tmpdir, "link")
 	target := tmpdir
-	if err := os.Symlink(target, link); err != nil {
+	err = os.Symlink(target, link)
+	if err != nil {
 		t.Fatal(err)
 	}
 	fi, err := os.Lstat(link)
--- a/src/archive/zip/reader.go
+++ b/src/archive/zip/reader.go
@@ -52,9 +52,12 @@ type File struct {
 	FileHeader
 	zip          *Reader
 	zipr         io.ReaderAt
+	zipsize      int64
 	headerOffset int64
-	zip64        bool  // zip64 extended information extra field presence
-	descErr      error // error reading the data descriptor during init
+}
+
+func (f *File) hasDataDescriptor() bool {
+	return f.Flags&0x8 != 0
 }

 // OpenReader will open the Zip file specified by name and return a ReadCloser.
@@ -96,15 +99,7 @@ func (z *Reader) init(r io.ReaderAt, size int64) error {
 		return err
 	}
 	z.r = r
-	// Since the number of directory records is not validated, it is not
-	// safe to preallocate z.File without first checking that the specified
-	// number of files is reasonable, since a malformed archive may
-	// indicate it contains up to 1 << 128 - 1 files. Since each file has a
-	// header which will be _at least_ 30 bytes we can safely preallocate
-	// if (data size / 30) >= end.directoryRecords.
-	if (uint64(size)-end.directorySize)/30 >= end.directoryRecords {
-		z.File = make([]*File, 0, end.directoryRecords)
-	}
+	z.File = make([]*File, 0, end.directoryRecords)
 	z.Comment = end.comment
 	rs := io.NewSectionReader(r, 0, size)
 	if _, err = rs.Seek(int64(end.directoryOffset), io.SeekStart); err != nil {
@@ -117,7 +112,7 @@ func (z *Reader) init(r io.ReaderAt, size int64) error {
 	// a bad one, and then only report an ErrFormat or UnexpectedEOF if
 	// the file count modulo 65536 is incorrect.
 	for {
-		f := &File{zip: z, zipr: r}
+		f := &File{zip: z, zipr: r, zipsize: size}
 		err = readDirectoryHeader(f, buf)
 		if err == ErrFormat || err == io.ErrUnexpectedEOF {
 			break
@@ -125,7 +120,6 @@ func (z *Reader) init(r io.ReaderAt, size int64) error {
 		if err != nil {
 			return err
 		}
-		f.readDataDescriptor()
 		z.File = append(z.File, f)
 	}
 	if uint16(len(z.File)) != uint16(end.directoryRecords) { // only compare 16 bits here
@@ -186,68 +180,26 @@ func (f *File) Open() (io.ReadCloser, error) {
 		return nil, ErrAlgorithm
 	}
 	var rc io.ReadCloser = dcomp(r)
+	var desr io.Reader
+	if f.hasDataDescriptor() {
+		desr = io.NewSectionReader(f.zipr, f.headerOffset+bodyOffset+size, dataDescriptorLen)
+	}
 	rc = &checksumReader{
 		rc:   rc,
 		hash: crc32.NewIEEE(),
 		f:    f,
+		desr: desr,
 	}
 	return rc, nil
 }

-// OpenRaw returns a Reader that provides access to the File's contents without
-// decompression.
-func (f *File) OpenRaw() (io.Reader, error) {
-	bodyOffset, err := f.findBodyOffset()
-	if err != nil {
-		return nil, err
-	}
-	r := io.NewSectionReader(f.zipr, f.headerOffset+bodyOffset, int64(f.CompressedSize64))
-	return r, nil
-}
-
-func (f *File) readDataDescriptor() {
-	if !f.hasDataDescriptor() {
-		return
-	}
-
-	bodyOffset, err := f.findBodyOffset()
-	if err != nil {
-		f.descErr = err
-		return
-	}
-
-	// In section 4.3.9.2 of the spec: "However ZIP64 format MAY be used
-	// regardless of the size of a file.  When extracting, if the zip64
-	// extended information extra field is present for the file the
-	// compressed and uncompressed sizes will be 8 byte values."
-	//
-	// Historically, this package has used the compressed and uncompressed
-	// sizes from the central directory to determine if the package is
-	// zip64.
-	//
-	// For this case we allow either the extra field or sizes to determine
-	// the data descriptor length.
-	zip64 := f.zip64 || f.isZip64()
-	n := int64(dataDescriptorLen)
-	if zip64 {
-		n = dataDescriptor64Len
-	}
-	size := int64(f.CompressedSize64)
-	r := io.NewSectionReader(f.zipr, f.headerOffset+bodyOffset+size, n)
-	dd, err := readDataDescriptor(r, zip64)
-	if err != nil {
-		f.descErr = err
-		return
-	}
-	f.CRC32 = dd.crc32
-}
-
 type checksumReader struct {
 	rc    io.ReadCloser
 	hash  hash.Hash32
 	nread uint64 // number of bytes read so far
 	f     *File
-	err   error // sticky error
+	desr  io.Reader // if non-nil, where to read the data descriptor
+	err   error     // sticky error
 }

 func (r *checksumReader) Stat() (fs.FileInfo, error) {
@@ -268,12 +220,12 @@ func (r *checksumReader) Read(b []byte) (n int, err error) {
 		if r.nread != r.f.UncompressedSize64 {
 			return 0, io.ErrUnexpectedEOF
 		}
-		if r.f.hasDataDescriptor() {
-			if r.f.descErr != nil {
-				if r.f.descErr == io.EOF {
+		if r.desr != nil {
+			if err1 := readDataDescriptor(r.desr, r.f); err1 != nil {
+				if err1 == io.EOF {
 					err = io.ErrUnexpectedEOF
 				} else {
-					err = r.f.descErr
+					err = err1
 				}
 			} else if r.hash.Sum32() != r.f.CRC32 {
 				err = ErrChecksum
@@ -384,8 +336,6 @@ parseExtras:

 		switch fieldTag {
 		case zip64ExtraID:
-			f.zip64 = true
-
 			// update directory values from the zip64 extra block.
 			// They should only be consulted if the sizes read earlier
 			// are maxed out.
@@ -485,9 +435,8 @@ parseExtras:
 	return nil
 }

-func readDataDescriptor(r io.Reader, zip64 bool) (*dataDescriptor, error) {
-	// Create enough space for the largest possible size
-	var buf [dataDescriptor64Len]byte
+func readDataDescriptor(r io.Reader, f *File) error {
+	var buf [dataDescriptorLen]byte

 	// The spec says: "Although not originally assigned a
 	// signature, the value 0x08074b50 has commonly been adopted
@@ -497,9 +446,10 @@ func readDataDescriptor(r io.Reader, zip64 bool) (*dataDescriptor, error) {
 	// descriptors and should account for either case when reading
 	// ZIP files to ensure compatibility."
 	//
-	// First read just those 4 bytes to see if the signature exists.
+	// dataDescriptorLen includes the size of the signature but
+	// first read just those 4 bytes to see if it exists.
 	if _, err := io.ReadFull(r, buf[:4]); err != nil {
-		return nil, err
+		return err
 	}
 	off := 0
 	maybeSig := readBuf(buf[:4])
@@ -508,28 +458,21 @@ func readDataDescriptor(r io.Reader, zip64 bool) (*dataDescriptor, error) {
 		// bytes.
 		off += 4
 	}
-
-	end := dataDescriptorLen - 4
-	if zip64 {
-		end = dataDescriptor64Len - 4
+	if _, err := io.ReadFull(r, buf[off:12]); err != nil {
+		return err
 	}
-	if _, err := io.ReadFull(r, buf[off:end]); err != nil {
-		return nil, err
-	}
-	b := readBuf(buf[:end])
-
-	out := &dataDescriptor{
-		crc32: b.uint32(),
+	b := readBuf(buf[:12])
+	if b.uint32() != f.CRC32 {
+		return ErrChecksum
 	}

-	if zip64 {
-		out.compressedSize = b.uint64()
-		out.uncompressedSize = b.uint64()
-	} else {
-		out.compressedSize = uint64(b.uint32())
-		out.uncompressedSize = uint64(b.uint32())
-	}
-	return out, nil
+	// The two sizes that follow here can be either 32 bits or 64 bits
+	// but the spec is not very clear on this and different
+	// interpretations has been made causing incompatibilities. We
+	// already have the sizes from the central directory so we can
+	// just ignore these.
+
+	return nil
 }

 func readDirectoryEnd(r io.ReaderAt, size int64) (dir *directoryEnd, err error) {
@@ -685,11 +628,10 @@ func (b *readBuf) sub(n int) readBuf {
 }

 // A fileListEntry is a File and its ename.
-// If file == nil, the fileListEntry describes a directory without metadata.
+// If file == nil, the fileListEntry describes a directory, without metadata.
 type fileListEntry struct {
-	name  string
-	file  *File
-	isDir bool
+	name string
+	file *File // nil for directories
 }

 type fileInfoDirEntry interface {
@@ -698,26 +640,20 @@ type fileInfoDirEntry interface {
 }

 func (e *fileListEntry) stat() fileInfoDirEntry {
-	if !e.isDir {
+	if e.file != nil {
 		return headerFileInfo{&e.file.FileHeader}
 	}
 	return e
 }

 // Only used for directories.
-func (f *fileListEntry) Name() string      { _, elem, _ := split(f.name); return elem }
-func (f *fileListEntry) Size() int64       { return 0 }
-func (f *fileListEntry) Mode() fs.FileMode { return fs.ModeDir | 0555 }
-func (f *fileListEntry) Type() fs.FileMode { return fs.ModeDir }
-func (f *fileListEntry) IsDir() bool       { return true }
-func (f *fileListEntry) Sys() interface{}  { return nil }
-
-func (f *fileListEntry) ModTime() time.Time {
-	if f.file == nil {
-		return time.Time{}
-	}
-	return f.file.FileHeader.Modified.UTC()
-}
+func (f *fileListEntry) Name() string       { _, elem, _ := split(f.name); return elem }
+func (f *fileListEntry) Size() int64        { return 0 }
+func (f *fileListEntry) ModTime() time.Time { return time.Time{} }
+func (f *fileListEntry) Mode() fs.FileMode  { return fs.ModeDir | 0555 }
+func (f *fileListEntry) Type() fs.FileMode  { return fs.ModeDir }
+func (f *fileListEntry) IsDir() bool        { return true }
+func (f *fileListEntry) Sys() interface{}   { return nil }

 func (f *fileListEntry) Info() (fs.FileInfo, error) { return f, nil }

@@ -737,32 +673,15 @@ func toValidName(name string) string {
 func (r *Reader) initFileList() {
 	r.fileListOnce.Do(func() {
 		dirs := make(map[string]bool)
-		knownDirs := make(map[string]bool)
 		for _, file := range r.File {
-			isDir := len(file.Name) > 0 && file.Name[len(file.Name)-1] == '/'
 			name := toValidName(file.Name)
 			for dir := path.Dir(name); dir != "."; dir = path.Dir(dir) {
 				dirs[dir] = true
 			}
-			entry := fileListEntry{
-				name:  name,
-				file:  file,
-				isDir: isDir,
-			}
-			r.fileList = append(r.fileList, entry)
-			if isDir {
-				knownDirs[name] = true
-			}
+			r.fileList = append(r.fileList, fileListEntry{name, file})
 		}
 		for dir := range dirs {
-			if !knownDirs[dir] {
-				entry := fileListEntry{
-					name:  dir,
-					file:  nil,
-					isDir: true,
-				}
-				r.fileList = append(r.fileList, entry)
-			}
+			r.fileList = append(r.fileList, fileListEntry{dir + "/", nil})
 		}

 		sort.Slice(r.fileList, func(i, j int) bool { return fileEntryLess(r.fileList[i].name, r.fileList[j].name) })
@@ -786,7 +705,7 @@ func (r *Reader) Open(name string) (fs.File, error) {
 	if e == nil || !fs.ValidPath(name) {
 		return nil, &fs.PathError{Op: "open", Path: name, Err: fs.ErrNotExist}
 	}
-	if e.isDir {
+	if e.file == nil || strings.HasSuffix(e.file.Name, "/") {
 		return &openDir{e, r.openReadDir(name), 0}, nil
 	}
 	rc, err := e.file.Open()
@@ -811,7 +730,7 @@ func split(name string) (dir, elem string, isDir bool) {
 	return name[:i], name[i+1:], isDir
 }

-var dotFile = &fileListEntry{name: "./", isDir: true}
+var dotFile = &fileListEntry{name: "./"}

 func (r *Reader) openLookup(name string) *fileListEntry {
 	if name == "." {
--- a/src/archive/zip/reader_test.go
+++ b/src/archive/zip/reader_test.go
@@ -499,15 +499,9 @@ func TestReader(t *testing.T) {
 func readTestZip(t *testing.T, zt ZipTest) {
 	var z *Reader
 	var err error
-	var raw []byte
 	if zt.Source != nil {
 		rat, size := zt.Source()
 		z, err = NewReader(rat, size)
-		raw = make([]byte, size)
-		if _, err := rat.ReadAt(raw, 0); err != nil {
-			t.Errorf("ReadAt error=%v", err)
-			return
-		}
 	} else {
 		path := filepath.Join("testdata", zt.Name)
 		if zt.Obscured {
@@ -525,12 +519,6 @@ func readTestZip(t *testing.T, zt ZipTest) {
 			defer rc.Close()
 			z = &rc.Reader
 		}
-		var err2 error
-		raw, err2 = os.ReadFile(path)
-		if err2 != nil {
-			t.Errorf("ReadFile(%s) error=%v", path, err2)
-			return
-		}
 	}
 	if err != zt.Error {
 		t.Errorf("error=%v, want %v", err, zt.Error)
@@ -557,7 +545,7 @@ func readTestZip(t *testing.T, zt ZipTest) {

 	// test read of each file
 	for i, ft := range zt.File {
-		readTestFile(t, zt, ft, z.File[i], raw)
+		readTestFile(t, zt, ft, z.File[i])
 	}
 	if t.Failed() {
 		return
@@ -569,7 +557,7 @@ func readTestZip(t *testing.T, zt ZipTest) {
 	for i := 0; i < 5; i++ {
 		for j, ft := range zt.File {
 			go func(j int, ft ZipTestFile) {
-				readTestFile(t, zt, ft, z.File[j], raw)
+				readTestFile(t, zt, ft, z.File[j])
 				done <- true
 			}(j, ft)
 			n++
@@ -586,7 +574,7 @@ func equalTimeAndZone(t1, t2 time.Time) bool {
 	return t1.Equal(t2) && name1 == name2 && offset1 == offset2
 }

-func readTestFile(t *testing.T, zt ZipTest, ft ZipTestFile, f *File, raw []byte) {
+func readTestFile(t *testing.T, zt ZipTest, ft ZipTestFile, f *File) {
 	if f.Name != ft.Name {
 		t.Errorf("name=%q, want %q", f.Name, ft.Name)
 	}
@@ -606,31 +594,6 @@ func readTestFile(t *testing.T, zt ZipTest, ft ZipTestFile, f *File, raw []byte)
 		t.Errorf("%v: UncompressedSize=%#x does not match UncompressedSize64=%#x", f.Name, size, f.UncompressedSize64)
 	}

-	// Check that OpenRaw returns the correct byte segment
-	rw, err := f.OpenRaw()
-	if err != nil {
-		t.Errorf("%v: OpenRaw error=%v", f.Name, err)
-		return
-	}
-	start, err := f.DataOffset()
-	if err != nil {
-		t.Errorf("%v: DataOffset error=%v", f.Name, err)
-		return
-	}
-	got, err := io.ReadAll(rw)
-	if err != nil {
-		t.Errorf("%v: OpenRaw ReadAll error=%v", f.Name, err)
-		return
-	}
-	end := uint64(start) + f.CompressedSize64
-	want := raw[start:end]
-	if !bytes.Equal(got, want) {
-		t.Logf("got %q", got)
-		t.Logf("want %q", want)
-		t.Errorf("%v: OpenRaw returned unexpected bytes", f.Name)
-		return
-	}
-
 	r, err := f.Open()
 	if err != nil {
 		t.Errorf("%v", err)
@@ -813,8 +776,8 @@ func returnRecursiveZip() (r io.ReaderAt, size int64) {
 //		"archive/zip"
 //		"bytes"
 //		"io"
+//		"io/ioutil"
 //		"log"
-//		"os"
 //	)
 //
 //	type zeros struct{}
@@ -1110,62 +1073,12 @@ func TestIssue12449(t *testing.T) {
 }

 func TestFS(t *testing.T) {
-	for _, test := range []struct {
-		file string
-		want []string
-	}{
-		{
-			"testdata/unix.zip",
-			[]string{"hello", "dir/bar", "readonly"},
-		},
-		{
-			"testdata/subdir.zip",
-			[]string{"a/b/c"},
-		},
-	} {
-		t.Run(test.file, func(t *testing.T) {
-			t.Parallel()
-			z, err := OpenReader(test.file)
-			if err != nil {
-				t.Fatal(err)
-			}
-			defer z.Close()
-			if err := fstest.TestFS(z, test.want...); err != nil {
-				t.Error(err)
-			}
-		})
-	}
-}
-
-func TestFSModTime(t *testing.T) {
-	t.Parallel()
-	z, err := OpenReader("testdata/subdir.zip")
+	z, err := OpenReader("testdata/unix.zip")
 	if err != nil {
 		t.Fatal(err)
 	}
-	defer z.Close()
-
-	for _, test := range []struct {
-		name string
-		want time.Time
-	}{
-		{
-			"a",
-			time.Date(2021, 4, 19, 12, 29, 56, 0, timeZone(-7*time.Hour)).UTC(),
-		},
-		{
-			"a/b/c",
-			time.Date(2021, 4, 19, 12, 29, 59, 0, timeZone(-7*time.Hour)).UTC(),
-		},
-	} {
-		fi, err := fs.Stat(z, test.name)
-		if err != nil {
-			t.Errorf("%s: %v", test.name, err)
-			continue
-		}
-		if got := fi.ModTime(); !got.Equal(test.want) {
-			t.Errorf("%s: got modtime %v, want %v", test.name, got, test.want)
-		}
+	if err := fstest.TestFS(z, "hello", "dir/bar", "dir/empty", "readonly"); err != nil {
+		t.Fatal(err)
 	}
 }

@@ -1203,184 +1116,3 @@ func TestCVE202127919(t *testing.T) {
 		t.Errorf("Error reading file: %v", err)
 	}
 }
-
-func TestReadDataDescriptor(t *testing.T) {
-	tests := []struct {
-		desc    string
-		in      []byte
-		zip64   bool
-		want    *dataDescriptor
-		wantErr error
-	}{{
-		desc: "valid 32 bit with signature",
-		in: []byte{
-			0x50, 0x4b, 0x07, 0x08, // signature
-			0x00, 0x01, 0x02, 0x03, // crc32
-			0x04, 0x05, 0x06, 0x07, // compressed size
-			0x08, 0x09, 0x0a, 0x0b, // uncompressed size
-		},
-		want: &dataDescriptor{
-			crc32:            0x03020100,
-			compressedSize:   0x07060504,
-			uncompressedSize: 0x0b0a0908,
-		},
-	}, {
-		desc: "valid 32 bit without signature",
-		in: []byte{
-			0x00, 0x01, 0x02, 0x03, // crc32
-			0x04, 0x05, 0x06, 0x07, // compressed size
-			0x08, 0x09, 0x0a, 0x0b, // uncompressed size
-		},
-		want: &dataDescriptor{
-			crc32:            0x03020100,
-			compressedSize:   0x07060504,
-			uncompressedSize: 0x0b0a0908,
-		},
-	}, {
-		desc: "valid 64 bit with signature",
-		in: []byte{
-			0x50, 0x4b, 0x07, 0x08, // signature
-			0x00, 0x01, 0x02, 0x03, // crc32
-			0x04, 0x05, 0x06, 0x07, 0x08, 0x09, 0x0a, 0x0b, // compressed size
-			0x0c, 0x0d, 0x0e, 0x0f, 0x10, 0x11, 0x12, 0x13, // uncompressed size
-		},
-		zip64: true,
-		want: &dataDescriptor{
-			crc32:            0x03020100,
-			compressedSize:   0x0b0a090807060504,
-			uncompressedSize: 0x131211100f0e0d0c,
-		},
-	}, {
-		desc: "valid 64 bit without signature",
-		in: []byte{
-			0x00, 0x01, 0x02, 0x03, // crc32
-			0x04, 0x05, 0x06, 0x07, 0x08, 0x09, 0x0a, 0x0b, // compressed size
-			0x0c, 0x0d, 0x0e, 0x0f, 0x10, 0x11, 0x12, 0x13, // uncompressed size
-		},
-		zip64: true,
-		want: &dataDescriptor{
-			crc32:            0x03020100,
-			compressedSize:   0x0b0a090807060504,
-			uncompressedSize: 0x131211100f0e0d0c,
-		},
-	}, {
-		desc: "invalid 32 bit with signature",
-		in: []byte{
-			0x50, 0x4b, 0x07, 0x08, // signature
-			0x00, 0x01, 0x02, 0x03, // crc32
-			0x04, 0x05, // unexpected end
-		},
-		wantErr: io.ErrUnexpectedEOF,
-	}, {
-		desc: "invalid 32 bit without signature",
-		in: []byte{
-			0x00, 0x01, 0x02, 0x03, // crc32
-			0x04, 0x05, // unexpected end
-		},
-		wantErr: io.ErrUnexpectedEOF,
-	}, {
-		desc: "invalid 64 bit with signature",
-		in: []byte{
-			0x50, 0x4b, 0x07, 0x08, // signature
-			0x00, 0x01, 0x02, 0x03, // crc32
-			0x04, 0x05, 0x06, 0x07, 0x08, 0x09, 0x0a, 0x0b, // compressed size
-			0x0c, 0x0d, 0x0e, 0x0f, 0x10, 0x11, // unexpected end
-		},
-		zip64:   true,
-		wantErr: io.ErrUnexpectedEOF,
-	}, {
-		desc: "invalid 64 bit without signature",
-		in: []byte{
-			0x00, 0x01, 0x02, 0x03, // crc32
-			0x04, 0x05, 0x06, 0x07, 0x08, 0x09, 0x0a, 0x0b, // compressed size
-			0x0c, 0x0d, 0x0e, 0x0f, 0x10, 0x11, // unexpected end
-		},
-		zip64:   true,
-		wantErr: io.ErrUnexpectedEOF,
-	}}
-
-	for _, test := range tests {
-		t.Run(test.desc, func(t *testing.T) {
-			r := bytes.NewReader(test.in)
-
-			desc, err := readDataDescriptor(r, test.zip64)
-			if err != test.wantErr {
-				t.Fatalf("got err %v; want nil", err)
-			}
-			if test.want == nil {
-				return
-			}
-			if desc == nil {
-				t.Fatalf("got nil DataDescriptor; want non-nil")
-			}
-			if desc.crc32 != test.want.crc32 {
-				t.Errorf("got CRC32 %#x; want %#x", desc.crc32, test.want.crc32)
-			}
-			if desc.compressedSize != test.want.compressedSize {
-				t.Errorf("got CompressedSize %#x; want %#x", desc.compressedSize, test.want.compressedSize)
-			}
-			if desc.uncompressedSize != test.want.uncompressedSize {
-				t.Errorf("got UncompressedSize %#x; want %#x", desc.uncompressedSize, test.want.uncompressedSize)
-			}
-		})
-	}
-}
-
-func TestCVE202133196(t *testing.T) {
-	// Archive that indicates it has 1 << 128 -1 files,
-	// this would previously cause a panic due to attempting
-	// to allocate a slice with 1 << 128 -1 elements.
-	data := []byte{
-		0x50, 0x4b, 0x03, 0x04, 0x14, 0x00, 0x08, 0x08,
-		0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-		0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-		0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x01, 0x02,
-		0x03, 0x62, 0x61, 0x65, 0x03, 0x04, 0x00, 0x00,
-		0xff, 0xff, 0x50, 0x4b, 0x07, 0x08, 0xbe, 0x20,
-		0x5c, 0x6c, 0x09, 0x00, 0x00, 0x00, 0x03, 0x00,
-		0x00, 0x00, 0x50, 0x4b, 0x01, 0x02, 0x14, 0x00,
-		0x14, 0x00, 0x08, 0x08, 0x08, 0x00, 0x00, 0x00,
-		0x00, 0x00, 0xbe, 0x20, 0x5c, 0x6c, 0x09, 0x00,
-		0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x03, 0x00,
-		0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-		0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-		0x01, 0x02, 0x03, 0x50, 0x4b, 0x06, 0x06, 0x2c,
-		0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x2d,
-		0x00, 0x2d, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-		0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00,
-		0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0xff,
-		0xff, 0xff, 0xff, 0x31, 0x00, 0x00, 0x00, 0x00,
-		0x00, 0x00, 0x00, 0x3a, 0x00, 0x00, 0x00, 0x00,
-		0x00, 0x00, 0x00, 0x50, 0x4b, 0x06, 0x07, 0x00,
-		0x00, 0x00, 0x00, 0x6b, 0x00, 0x00, 0x00, 0x00,
-		0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x50,
-		0x4b, 0x05, 0x06, 0x00, 0x00, 0x00, 0x00, 0xff,
-		0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
-		0xff, 0xff, 0xff, 0x00, 0x00,
-	}
-	_, err := NewReader(bytes.NewReader(data), int64(len(data)))
-	if err != ErrFormat {
-		t.Fatalf("unexpected error, got: %v, want: %v", err, ErrFormat)
-	}
-
-	// Also check that an archive containing a handful of empty
-	// files doesn't cause an issue
-	b := bytes.NewBuffer(nil)
-	w := NewWriter(b)
-	for i := 0; i < 5; i++ {
-		_, err := w.Create("")
-		if err != nil {
-			t.Fatalf("Writer.Create failed: %s", err)
-		}
-	}
-	if err := w.Close(); err != nil {
-		t.Fatalf("Writer.Close failed: %s", err)
-	}
-	r, err := NewReader(bytes.NewReader(b.Bytes()), int64(b.Len()))
-	if err != nil {
-		t.Fatalf("NewReader failed: %s", err)
-	}
-	if len(r.File) != 5 {
-		t.Errorf("Archive has unexpected number of files, got %d, want 5", len(r.File))
-	}
-}
--- a/src/archive/zip/struct.go
+++ b/src/archive/zip/struct.go
@@ -42,7 +42,7 @@ const (
 	directoryHeaderLen       = 46         // + filename + extra + comment
 	directoryEndLen          = 22         // + comment
 	dataDescriptorLen        = 16         // four uint32: descriptor signature, crc32, compressed size, size
-	dataDescriptor64Len      = 24         // two uint32: signature, crc32 | two uint64: compressed size, size
+	dataDescriptor64Len      = 24         // descriptor with 8 byte sizes
 	directory64LocLen        = 20         //
 	directory64EndLen        = 56         // + extra

@@ -315,10 +315,6 @@ func (h *FileHeader) isZip64() bool {
 	return h.CompressedSize64 >= uint32max || h.UncompressedSize64 >= uint32max
 }

-func (f *FileHeader) hasDataDescriptor() bool {
-	return f.Flags&0x8 != 0
-}
-
 func msdosModeToFileMode(m uint32) (mode fs.FileMode) {
 	if m&msdosDir != 0 {
 		mode = fs.ModeDir | 0777
@@ -345,9 +341,11 @@ func fileModeToUnixMode(mode fs.FileMode) uint32 {
 	case fs.ModeSocket:
 		m = s_IFSOCK
 	case fs.ModeDevice:
-		m = s_IFBLK
-	case fs.ModeDevice | fs.ModeCharDevice:
-		m = s_IFCHR
+		if mode&fs.ModeCharDevice != 0 {
+			m = s_IFCHR
+		} else {
+			m = s_IFBLK
+		}
 	}
 	if mode&fs.ModeSetuid != 0 {
 		m |= s_ISUID
@@ -390,11 +388,3 @@ func unixModeToFileMode(m uint32) fs.FileMode {
 	}
 	return mode
 }
-
-// dataDescriptor holds the data descriptor that optionally follows the file
-// contents in the zip file.
-type dataDescriptor struct {
-	crc32            uint32
-	compressedSize   uint64
-	uncompressedSize uint64
-}
--- a/src/archive/zip/testdata/subdir.zip
+++ b/src/archive/zip/testdata/subdir.zip
--- a/src/archive/zip/writer.go
+++ b/src/archive/zip/writer.go
@@ -37,7 +37,6 @@ type Writer struct {
 type header struct {
 	*FileHeader
 	offset uint64
-	raw    bool
 }

 // NewWriter returns a new Writer writing a zip file to w.
@@ -246,31 +245,22 @@ func detectUTF8(s string) (valid, require bool) {
 	return true, require
 }

-// prepare performs the bookkeeping operations required at the start of
-// CreateHeader and CreateRaw.
-func (w *Writer) prepare(fh *FileHeader) error {
-	if w.last != nil && !w.last.closed {
-		if err := w.last.close(); err != nil {
-			return err
-		}
-	}
-	if len(w.dir) > 0 && w.dir[len(w.dir)-1].FileHeader == fh {
-		// See https://golang.org/issue/11144 confusion.
-		return errors.New("archive/zip: invalid duplicate FileHeader")
-	}
-	return nil
-}
-
 // CreateHeader adds a file to the zip archive using the provided FileHeader
 // for the file metadata. Writer takes ownership of fh and may mutate
 // its fields. The caller must not modify fh after calling CreateHeader.
 //
 // This returns a Writer to which the file contents should be written.
 // The file's contents must be written to the io.Writer before the next
-// call to Create, CreateHeader, CreateRaw, or Close.
+// call to Create, CreateHeader, or Close.
 func (w *Writer) CreateHeader(fh *FileHeader) (io.Writer, error) {
-	if err := w.prepare(fh); err != nil {
-		return nil, err
+	if w.last != nil && !w.last.closed {
+		if err := w.last.close(); err != nil {
+			return nil, err
+		}
+	}
+	if len(w.dir) > 0 && w.dir[len(w.dir)-1].FileHeader == fh {
+		// See https://golang.org/issue/11144 confusion.
+		return nil, errors.New("archive/zip: invalid duplicate FileHeader")
 	}

 	// The ZIP format has a sad state of affairs regarding character encoding.
@@ -375,7 +365,7 @@ func (w *Writer) CreateHeader(fh *FileHeader) (io.Writer, error) {
 		ow = fw
 	}
 	w.dir = append(w.dir, h)
-	if err := writeHeader(w.cw, h); err != nil {
+	if err := writeHeader(w.cw, fh); err != nil {
 		return nil, err
 	}
 	// If we're creating a directory, fw is nil.
@@ -383,7 +373,7 @@ func (w *Writer) CreateHeader(fh *FileHeader) (io.Writer, error) {
 	return ow, nil
 }

-func writeHeader(w io.Writer, h *header) error {
+func writeHeader(w io.Writer, h *FileHeader) error {
 	const maxUint16 = 1<<16 - 1
 	if len(h.Name) > maxUint16 {
 		return errLongName
@@ -400,20 +390,9 @@ func writeHeader(w io.Writer, h *header) error {
 	b.uint16(h.Method)
 	b.uint16(h.ModifiedTime)
 	b.uint16(h.ModifiedDate)
-	// In raw mode (caller does the compression), the values are either
-	// written here or in the trailing data descriptor based on the header
-	// flags.
-	if h.raw && !h.hasDataDescriptor() {
-		b.uint32(h.CRC32)
-		b.uint32(uint32(min64(h.CompressedSize64, uint32max)))
-		b.uint32(uint32(min64(h.UncompressedSize64, uint32max)))
-	} else {
-		// When this package handle the compression, these values are
-		// always written to the trailing data descriptor.
-		b.uint32(0) // crc32
-		b.uint32(0) // compressed size
-		b.uint32(0) // uncompressed size
-	}
+	b.uint32(0) // since we are writing a data descriptor crc32,
+	b.uint32(0) // compressed size,
+	b.uint32(0) // and uncompressed size should be zero
 	b.uint16(uint16(len(h.Name)))
 	b.uint16(uint16(len(h.Extra)))
 	if _, err := w.Write(buf[:]); err != nil {
@@ -426,65 +405,6 @@ func writeHeader(w io.Writer, h *header) error {
 	return err
 }

-func min64(x, y uint64) uint64 {
-	if x < y {
-		return x
-	}
-	return y
-}
-
-// CreateRaw adds a file to the zip archive using the provided FileHeader and
-// returns a Writer to which the file contents should be written. The file's
-// contents must be written to the io.Writer before the next call to Create,
-// CreateHeader, CreateRaw, or Close.
-//
-// In contrast to CreateHeader, the bytes passed to Writer are not compressed.
-func (w *Writer) CreateRaw(fh *FileHeader) (io.Writer, error) {
-	if err := w.prepare(fh); err != nil {
-		return nil, err
-	}
-
-	fh.CompressedSize = uint32(min64(fh.CompressedSize64, uint32max))
-	fh.UncompressedSize = uint32(min64(fh.UncompressedSize64, uint32max))
-
-	h := &header{
-		FileHeader: fh,
-		offset:     uint64(w.cw.count),
-		raw:        true,
-	}
-	w.dir = append(w.dir, h)
-	if err := writeHeader(w.cw, h); err != nil {
-		return nil, err
-	}
-
-	if strings.HasSuffix(fh.Name, "/") {
-		w.last = nil
-		return dirWriter{}, nil
-	}
-
-	fw := &fileWriter{
-		header: h,
-		zipw:   w.cw,
-	}
-	w.last = fw
-	return fw, nil
-}
-
-// Copy copies the file f (obtained from a Reader) into w. It copies the raw
-// form directly bypassing decompression, compression, and validation.
-func (w *Writer) Copy(f *File) error {
-	r, err := f.OpenRaw()
-	if err != nil {
-		return err
-	}
-	fw, err := w.CreateRaw(&f.FileHeader)
-	if err != nil {
-		return err
-	}
-	_, err = io.Copy(fw, r)
-	return err
-}
-
 // RegisterCompressor registers or overrides a custom compressor for a specific
 // method ID. If a compressor for a given method is not found, Writer will
 // default to looking up the compressor at the package level.
@@ -526,9 +446,6 @@ func (w *fileWriter) Write(p []byte) (int, error) {
 	if w.closed {
 		return 0, errors.New("zip: write to closed file")
 	}
-	if w.raw {
-		return w.zipw.Write(p)
-	}
 	w.crc32.Write(p)
 	return w.rawCount.Write(p)
 }
@@ -538,9 +455,6 @@ func (w *fileWriter) close() error {
 		return errors.New("zip: file closed twice")
 	}
 	w.closed = true
-	if w.raw {
-		return w.writeDataDescriptor()
-	}
 	if err := w.comp.Close(); err != nil {
 		return err
 	}
@@ -560,33 +474,26 @@ func (w *fileWriter) close() error {
 		fh.UncompressedSize = uint32(fh.UncompressedSize64)
 	}

-	return w.writeDataDescriptor()
-}
-
-func (w *fileWriter) writeDataDescriptor() error {
-	if !w.hasDataDescriptor() {
-		return nil
-	}
 	// Write data descriptor. This is more complicated than one would
 	// think, see e.g. comments in zipfile.c:putextended() and
 	// http://bugs.sun.com/bugdatabase/view_bug.do?bug_id=7073588.
 	// The approach here is to write 8 byte sizes if needed without
 	// adding a zip64 extra in the local header (too late anyway).
 	var buf []byte
-	if w.isZip64() {
+	if fh.isZip64() {
 		buf = make([]byte, dataDescriptor64Len)
 	} else {
 		buf = make([]byte, dataDescriptorLen)
 	}
 	b := writeBuf(buf)
 	b.uint32(dataDescriptorSignature) // de-facto standard, required by OS X
-	b.uint32(w.CRC32)
-	if w.isZip64() {
-		b.uint64(w.CompressedSize64)
-		b.uint64(w.UncompressedSize64)
+	b.uint32(fh.CRC32)
+	if fh.isZip64() {
+		b.uint64(fh.CompressedSize64)
+		b.uint64(fh.UncompressedSize64)
 	} else {
-		b.uint32(w.CompressedSize)
-		b.uint32(w.UncompressedSize)
+		b.uint32(fh.CompressedSize)
+		b.uint32(fh.UncompressedSize)
 	}
 	_, err := w.zipw.Write(buf)
 	return err
--- a/src/archive/zip/writer_test.go
+++ b/src/archive/zip/writer_test.go
@@ -6,10 +6,8 @@ package zip

 import (
 	"bytes"
-	"compress/flate"
 	"encoding/binary"
 	"fmt"
-	"hash/crc32"
 	"io"
 	"io/fs"
 	"math/rand"
@@ -59,18 +57,6 @@ var writeTests = []WriteTest{
 		Method: Deflate,
 		Mode:   0755 | fs.ModeSymlink,
 	},
-	{
-		Name:   "device",
-		Data:   []byte("device file"),
-		Method: Deflate,
-		Mode:   0755 | fs.ModeDevice,
-	},
-	{
-		Name:   "chardevice",
-		Data:   []byte("char device file"),
-		Method: Deflate,
-		Mode:   0755 | fs.ModeDevice | fs.ModeCharDevice,
-	},
 }

 func TestWriter(t *testing.T) {
@@ -367,171 +353,6 @@ func TestWriterDirAttributes(t *testing.T) {
 	}
 }

-func TestWriterCopy(t *testing.T) {
-	// make a zip file
-	buf := new(bytes.Buffer)
-	w := NewWriter(buf)
-	for _, wt := range writeTests {
-		testCreate(t, w, &wt)
-	}
-	if err := w.Close(); err != nil {
-		t.Fatal(err)
-	}
-
-	// read it back
-	src, err := NewReader(bytes.NewReader(buf.Bytes()), int64(buf.Len()))
-	if err != nil {
-		t.Fatal(err)
-	}
-	for i, wt := range writeTests {
-		testReadFile(t, src.File[i], &wt)
-	}
-
-	// make a new zip file copying the old compressed data.
-	buf2 := new(bytes.Buffer)
-	dst := NewWriter(buf2)
-	for _, f := range src.File {
-		if err := dst.Copy(f); err != nil {
-			t.Fatal(err)
-		}
-	}
-	if err := dst.Close(); err != nil {
-		t.Fatal(err)
-	}
-
-	// read the new one back
-	r, err := NewReader(bytes.NewReader(buf2.Bytes()), int64(buf2.Len()))
-	if err != nil {
-		t.Fatal(err)
-	}
-	for i, wt := range writeTests {
-		testReadFile(t, r.File[i], &wt)
-	}
-}
-
-func TestWriterCreateRaw(t *testing.T) {
-	files := []struct {
-		name             string
-		content          []byte
-		method           uint16
-		flags            uint16
-		crc32            uint32
-		uncompressedSize uint64
-		compressedSize   uint64
-	}{
-		{
-			name:    "small store w desc",
-			content: []byte("gophers"),
-			method:  Store,
-			flags:   0x8,
-		},
-		{
-			name:    "small deflate wo desc",
-			content: bytes.Repeat([]byte("abcdefg"), 2048),
-			method:  Deflate,
-		},
-	}
-
-	// write a zip file
-	archive := new(bytes.Buffer)
-	w := NewWriter(archive)
-
-	for i := range files {
-		f := &files[i]
-		f.crc32 = crc32.ChecksumIEEE(f.content)
-		size := uint64(len(f.content))
-		f.uncompressedSize = size
-		f.compressedSize = size
-
-		var compressedContent []byte
-		if f.method == Deflate {
-			var buf bytes.Buffer
-			w, err := flate.NewWriter(&buf, flate.BestSpeed)
-			if err != nil {
-				t.Fatalf("flate.NewWriter err = %v", err)
-			}
-			_, err = w.Write(f.content)
-			if err != nil {
-				t.Fatalf("flate Write err = %v", err)
-			}
-			err = w.Close()
-			if err != nil {
-				t.Fatalf("flate Writer.Close err = %v", err)
-			}
-			compressedContent = buf.Bytes()
-			f.compressedSize = uint64(len(compressedContent))
-		}
-
-		h := &FileHeader{
-			Name:               f.name,
-			Method:             f.method,
-			Flags:              f.flags,
-			CRC32:              f.crc32,
-			CompressedSize64:   f.compressedSize,
-			UncompressedSize64: f.uncompressedSize,
-		}
-		w, err := w.CreateRaw(h)
-		if err != nil {
-			t.Fatal(err)
-		}
-		if compressedContent != nil {
-			_, err = w.Write(compressedContent)
-		} else {
-			_, err = w.Write(f.content)
-		}
-		if err != nil {
-			t.Fatalf("%s Write got %v; want nil", f.name, err)
-		}
-	}
-
-	if err := w.Close(); err != nil {
-		t.Fatal(err)
-	}
-
-	// read it back
-	r, err := NewReader(bytes.NewReader(archive.Bytes()), int64(archive.Len()))
-	if err != nil {
-		t.Fatal(err)
-	}
-	for i, want := range files {
-		got := r.File[i]
-		if got.Name != want.name {
-			t.Errorf("got Name %s; want %s", got.Name, want.name)
-		}
-		if got.Method != want.method {
-			t.Errorf("%s: got Method %#x; want %#x", want.name, got.Method, want.method)
-		}
-		if got.Flags != want.flags {
-			t.Errorf("%s: got Flags %#x; want %#x", want.name, got.Flags, want.flags)
-		}
-		if got.CRC32 != want.crc32 {
-			t.Errorf("%s: got CRC32 %#x; want %#x", want.name, got.CRC32, want.crc32)
-		}
-		if got.CompressedSize64 != want.compressedSize {
-			t.Errorf("%s: got CompressedSize64 %d; want %d", want.name, got.CompressedSize64, want.compressedSize)
-		}
-		if got.UncompressedSize64 != want.uncompressedSize {
-			t.Errorf("%s: got UncompressedSize64 %d; want %d", want.name, got.UncompressedSize64, want.uncompressedSize)
-		}
-
-		r, err := got.Open()
-		if err != nil {
-			t.Errorf("%s: Open err = %v", got.Name, err)
-			continue
-		}
-
-		buf, err := io.ReadAll(r)
-		if err != nil {
-			t.Errorf("%s: ReadAll err = %v", got.Name, err)
-			continue
-		}
-
-		if !bytes.Equal(buf, want.content) {
-			t.Errorf("%v: ReadAll returned unexpected bytes", got.Name)
-		}
-	}
-}
-
 func testCreate(t *testing.T, w *Writer, wt *WriteTest) {
 	header := &FileHeader{
 		Name:   wt.Name,
@@ -557,15 +378,15 @@ func testReadFile(t *testing.T, f *File, wt *WriteTest) {
 	testFileMode(t, f, wt.Mode)
 	rc, err := f.Open()
 	if err != nil {
-		t.Fatalf("opening %s: %v", f.Name, err)
+		t.Fatal("opening:", err)
 	}
 	b, err := io.ReadAll(rc)
 	if err != nil {
-		t.Fatalf("reading %s: %v", f.Name, err)
+		t.Fatal("reading:", err)
 	}
 	err = rc.Close()
 	if err != nil {
-		t.Fatalf("closing %s: %v", f.Name, err)
+		t.Fatal("closing:", err)
 	}
 	if !bytes.Equal(b, wt.Data) {
 		t.Errorf("File contents %q, want %q", b, wt.Data)
--- a/src/bufio/bufio.go
+++ b/src/bufio/bufio.go
@@ -670,8 +670,7 @@ func (b *Writer) WriteByte(c byte) error {
 // WriteRune writes a single Unicode code point, returning
 // the number of bytes written and any error.
 func (b *Writer) WriteRune(r rune) (size int, err error) {
-	// Compare as uint32 to correctly handle negative runes.
-	if uint32(r) < utf8.RuneSelf {
+	if r < utf8.RuneSelf {
 		err = b.WriteByte(byte(r))
 		if err != nil {
 			return 0, err
--- a/src/bufio/bufio_test.go
+++ b/src/bufio/bufio_test.go
@@ -534,20 +534,6 @@ func TestReadWriteRune(t *testing.T) {
 	}
 }

-func TestWriteInvalidRune(t *testing.T) {
-	// Invalid runes, including negative ones, should be written as the
-	// replacement character.
-	for _, r := range []rune{-1, utf8.MaxRune + 1} {
-		var buf bytes.Buffer
-		w := NewWriter(&buf)
-		w.WriteRune(r)
-		w.Flush()
-		if s := buf.String(); s != "\uFFFD" {
-			t.Errorf("WriteRune(%d) wrote %q, not replacement character", r, s)
-		}
-	}
-}
-
 func TestReadStringAllocs(t *testing.T) {
 	r := strings.NewReader("       foo       foo        42        42        42        42        42        42        42        42       4.2       4.2       4.2       4.2\n")
 	buf := NewReader(r)
--- a/src/bufio/scan.go
+++ b/src/bufio/scan.go
@@ -48,8 +48,7 @@ type Scanner struct {
 // and the next token to return to the user, if any, plus an error, if any.
 //
 // Scanning stops if the function returns an error, in which case some of
-// the input may be discarded. If that error is ErrFinalToken, scanning
-// stops with no error.
+// the input may be discarded.
 //
 // Otherwise, the Scanner advances the input. If the token is not nil,
 // the Scanner returns it to the user. If the token is nil, the
--- a/src/bytes/boundary_test.go
+++ b/src/bytes/boundary_test.go
@@ -2,7 +2,6 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 //
-//go:build linux
 // +build linux

 package bytes_test
--- a/src/bytes/buffer.go
+++ b/src/bytes/buffer.go
@@ -275,8 +275,7 @@ func (b *Buffer) WriteByte(c byte) error {
 // included to match bufio.Writer's WriteRune. The buffer is grown as needed;
 // if it becomes too large, WriteRune will panic with ErrTooLarge.
 func (b *Buffer) WriteRune(r rune) (n int, err error) {
-	// Compare as uint32 to correctly handle negative runes.
-	if uint32(r) < utf8.RuneSelf {
+	if r < utf8.RuneSelf {
 		b.WriteByte(byte(r))
 		return 1, nil
 	}
--- a/src/bytes/buffer_test.go
+++ b/src/bytes/buffer_test.go
@@ -6,7 +6,6 @@ package bytes_test

 import (
 	. "bytes"
-	"fmt"
 	"io"
 	"math/rand"
 	"testing"
@@ -388,16 +387,6 @@ func TestRuneIO(t *testing.T) {
 	}
 }

-func TestWriteInvalidRune(t *testing.T) {
-	// Invalid runes, including negative ones, should be written as
-	// utf8.RuneError.
-	for _, r := range []rune{-1, utf8.MaxRune + 1} {
-		var buf Buffer
-		buf.WriteRune(r)
-		check(t, fmt.Sprintf("TestWriteInvalidRune (%d)", r), &buf, "\uFFFD")
-	}
-}
-
 func TestNext(t *testing.T) {
 	b := []byte{0, 1, 2, 3, 4}
 	tmp := make([]byte, 5)
--- a/src/cmd/api/goapi.go
+++ b/src/cmd/api/goapi.go
@@ -215,7 +215,8 @@ func main() {
 	}
 	optional := fileFeatures(*nextFile)
 	exception := fileFeatures(*exceptFile)
-	fail = !compareAPI(bw, features, required, optional, exception, *allowNew)
+	fail = !compareAPI(bw, features, required, optional, exception,
+		*allowNew && strings.Contains(runtime.Version(), "devel"))
 }

 // export emits the exported package features.
--- a/src/cmd/api/run.go
+++ b/src/cmd/api/run.go
@@ -2,7 +2,6 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.

-//go:build ignore
 // +build ignore

 // The run program is invoked via the dist tool.
@@ -10,11 +9,8 @@
 package main

 import (
-	"errors"
 	"fmt"
 	exec "internal/execabs"
-	"internal/goversion"
-	"io/fs"
 	"log"
 	"os"
 	"path/filepath"
@@ -46,7 +42,6 @@ func main() {
 	apiDir := filepath.Join(goroot, "api")
 	out, err := exec.Command(goCmd(), "tool", "api",
 		"-c", findAPIDirFiles(apiDir),
-		allowNew(apiDir),
 		"-next", filepath.Join(apiDir, "next.txt"),
 		"-except", filepath.Join(apiDir, "except.txt")).CombinedOutput()
 	if err != nil {
@@ -75,35 +70,3 @@ func findAPIDirFiles(apiDir string) string {
 	}
 	return strings.Join(apiFiles, ",")
 }
-
-// allowNew returns the -allow_new flag to use for the 'go tool api' invocation.
-func allowNew(apiDir string) string {
-	// Verify that the api/go1.n.txt for previous Go version exists.
-	// It definitely should, otherwise it's a signal that the logic below may be outdated.
-	if _, err := os.Stat(filepath.Join(apiDir, fmt.Sprintf("go1.%d.txt", goversion.Version-1))); err != nil {
-		log.Fatalln("Problem with api file for previous release:", err)
-	}
-
-	// See whether the api/go1.n.txt for this Go version has been created.
-	// (As of April 2021, it gets created during the release of the first Beta.)
-	_, err := os.Stat(filepath.Join(apiDir, fmt.Sprintf("go1.%d.txt", goversion.Version)))
-	if errors.Is(err, fs.ErrNotExist) {
-		// It doesn't exist, so we're in development or before Beta 1.
-		// At this stage, unmentioned API additions are deemed okay.
-		// (They will be quietly shown in API check output, but the test won't fail).
-		return "-allow_new=true"
-	} else if err == nil {
-		// The api/go1.n.txt for this Go version has been created,
-		// so we're definitely past Beta 1 in the release cycle.
-		//
-		// From this point, enforce that api/go1.n.txt is an accurate and complete
-		// representation of what's going into the release by failing API check if
-		// there are API additions (a month into the freeze, there shouldn't be many).
-		//
-		// See golang.org/issue/43956.
-		return "-allow_new=false"
-	} else {
-		log.Fatal(err)
-	}
-	panic("unreachable")
-}
--- a/src/cmd/asm/internal/arch/arch.go
+++ b/src/cmd/asm/internal/arch/arch.go
@@ -109,10 +109,6 @@ func archX86(linkArch *obj.LinkArch) *Arch {
 	register["SB"] = RSB
 	register["FP"] = RFP
 	register["PC"] = RPC
-	if linkArch == &x86.Linkamd64 {
-		// Alias g to R14
-		register["g"] = x86.REGG
-	}
 	// Register prefix not used on this architecture.

 	instructions := make(map[string]obj.As)
--- a/src/cmd/asm/internal/arch/arm64.go
+++ b/src/cmd/asm/internal/arch/arm64.go
@@ -147,16 +147,7 @@ func arm64RegisterNumber(name string, n int16) (int16, bool) {
 	return 0, false
 }

-// ARM64RegisterShift constructs an ARM64 register with shift operation.
-func ARM64RegisterShift(reg, op, count int16) (int64, error) {
-	// the base register of shift operations must be general register.
-	if reg > arm64.REG_R31 || reg < arm64.REG_R0 {
-		return 0, errors.New("invalid register for shift operation")
-	}
-	return int64(reg&31)<<16 | int64(op)<<22 | int64(uint16(count)), nil
-}
-
-// ARM64RegisterExtension constructs an ARM64 register with extension or arrangement.
+// ARM64RegisterExtension parses an ARM64 register with extension or arrangement.
 func ARM64RegisterExtension(a *obj.Addr, ext string, reg, num int16, isAmount, isIndex bool) error {
 	Rnum := (reg & 31) + int16(num<<5)
 	if isAmount {
@@ -164,163 +155,154 @@ func ARM64RegisterExtension(a *obj.Addr, ext string, reg, num int16, isAmount, i
 			return errors.New("index shift amount is out of range")
 		}
 	}
-	if reg <= arm64.REG_R31 && reg >= arm64.REG_R0 {
-		switch ext {
-		case "UXTB":
-			if !isAmount {
-				return errors.New("invalid register extension")
-			}
-			if a.Type == obj.TYPE_MEM {
-				return errors.New("invalid shift for the register offset addressing mode")
-			}
-			a.Reg = arm64.REG_UXTB + Rnum
-		case "UXTH":
-			if !isAmount {
-				return errors.New("invalid register extension")
-			}
-			if a.Type == obj.TYPE_MEM {
-				return errors.New("invalid shift for the register offset addressing mode")
-			}
-			a.Reg = arm64.REG_UXTH + Rnum
-		case "UXTW":
-			if !isAmount {
-				return errors.New("invalid register extension")
-			}
-			// effective address of memory is a base register value and an offset register value.
-			if a.Type == obj.TYPE_MEM {
-				a.Index = arm64.REG_UXTW + Rnum
-			} else {
-				a.Reg = arm64.REG_UXTW + Rnum
-			}
-		case "UXTX":
-			if !isAmount {
-				return errors.New("invalid register extension")
-			}
-			if a.Type == obj.TYPE_MEM {
-				return errors.New("invalid shift for the register offset addressing mode")
-			}
-			a.Reg = arm64.REG_UXTX + Rnum
-		case "SXTB":
-			if !isAmount {
-				return errors.New("invalid register extension")
-			}
-			a.Reg = arm64.REG_SXTB + Rnum
-		case "SXTH":
-			if !isAmount {
-				return errors.New("invalid register extension")
-			}
-			if a.Type == obj.TYPE_MEM {
-				return errors.New("invalid shift for the register offset addressing mode")
-			}
-			a.Reg = arm64.REG_SXTH + Rnum
-		case "SXTW":
-			if !isAmount {
-				return errors.New("invalid register extension")
-			}
-			if a.Type == obj.TYPE_MEM {
-				a.Index = arm64.REG_SXTW + Rnum
-			} else {
-				a.Reg = arm64.REG_SXTW + Rnum
-			}
-		case "SXTX":
-			if !isAmount {
-				return errors.New("invalid register extension")
-			}
-			if a.Type == obj.TYPE_MEM {
-				a.Index = arm64.REG_SXTX + Rnum
-			} else {
-				a.Reg = arm64.REG_SXTX + Rnum
-			}
-		case "LSL":
-			if !isAmount {
-				return errors.New("invalid register extension")
-			}
-			a.Index = arm64.REG_LSL + Rnum
-		default:
-			return errors.New("unsupported general register extension type: " + ext)
-
+	switch ext {
+	case "UXTB":
+		if !isAmount {
+			return errors.New("invalid register extension")
 		}
-	} else if reg <= arm64.REG_V31 && reg >= arm64.REG_V0 {
-		switch ext {
-		case "B8":
-			if isIndex {
-				return errors.New("invalid register extension")
-			}
-			a.Reg = arm64.REG_ARNG + (reg & 31) + ((arm64.ARNG_8B & 15) << 5)
-		case "B16":
-			if isIndex {
-				return errors.New("invalid register extension")
-			}
-			a.Reg = arm64.REG_ARNG + (reg & 31) + ((arm64.ARNG_16B & 15) << 5)
-		case "H4":
-			if isIndex {
-				return errors.New("invalid register extension")
-			}
-			a.Reg = arm64.REG_ARNG + (reg & 31) + ((arm64.ARNG_4H & 15) << 5)
-		case "H8":
-			if isIndex {
-				return errors.New("invalid register extension")
-			}
-			a.Reg = arm64.REG_ARNG + (reg & 31) + ((arm64.ARNG_8H & 15) << 5)
-		case "S2":
-			if isIndex {
-				return errors.New("invalid register extension")
-			}
-			a.Reg = arm64.REG_ARNG + (reg & 31) + ((arm64.ARNG_2S & 15) << 5)
-		case "S4":
-			if isIndex {
-				return errors.New("invalid register extension")
-			}
-			a.Reg = arm64.REG_ARNG + (reg & 31) + ((arm64.ARNG_4S & 15) << 5)
-		case "D1":
-			if isIndex {
-				return errors.New("invalid register extension")
-			}
-			a.Reg = arm64.REG_ARNG + (reg & 31) + ((arm64.ARNG_1D & 15) << 5)
-		case "D2":
-			if isIndex {
-				return errors.New("invalid register extension")
-			}
-			a.Reg = arm64.REG_ARNG + (reg & 31) + ((arm64.ARNG_2D & 15) << 5)
-		case "Q1":
-			if isIndex {
-				return errors.New("invalid register extension")
-			}
-			a.Reg = arm64.REG_ARNG + (reg & 31) + ((arm64.ARNG_1Q & 15) << 5)
-		case "B":
-			if !isIndex {
-				return nil
-			}
-			a.Reg = arm64.REG_ELEM + (reg & 31) + ((arm64.ARNG_B & 15) << 5)
-			a.Index = num
-		case "H":
-			if !isIndex {
-				return nil
-			}
-			a.Reg = arm64.REG_ELEM + (reg & 31) + ((arm64.ARNG_H & 15) << 5)
-			a.Index = num
-		case "S":
-			if !isIndex {
-				return nil
-			}
-			a.Reg = arm64.REG_ELEM + (reg & 31) + ((arm64.ARNG_S & 15) << 5)
-			a.Index = num
-		case "D":
-			if !isIndex {
-				return nil
-			}
-			a.Reg = arm64.REG_ELEM + (reg & 31) + ((arm64.ARNG_D & 15) << 5)
-			a.Index = num
-		default:
-			return errors.New("unsupported simd register extension type: " + ext)
+		if a.Type == obj.TYPE_MEM {
+			return errors.New("invalid shift for the register offset addressing mode")
 		}
-	} else {
-		return errors.New("invalid register and extension combination")
+		a.Reg = arm64.REG_UXTB + Rnum
+	case "UXTH":
+		if !isAmount {
+			return errors.New("invalid register extension")
+		}
+		if a.Type == obj.TYPE_MEM {
+			return errors.New("invalid shift for the register offset addressing mode")
+		}
+		a.Reg = arm64.REG_UXTH + Rnum
+	case "UXTW":
+		if !isAmount {
+			return errors.New("invalid register extension")
+		}
+		// effective address of memory is a base register value and an offset register value.
+		if a.Type == obj.TYPE_MEM {
+			a.Index = arm64.REG_UXTW + Rnum
+		} else {
+			a.Reg = arm64.REG_UXTW + Rnum
+		}
+	case "UXTX":
+		if !isAmount {
+			return errors.New("invalid register extension")
+		}
+		if a.Type == obj.TYPE_MEM {
+			return errors.New("invalid shift for the register offset addressing mode")
+		}
+		a.Reg = arm64.REG_UXTX + Rnum
+	case "SXTB":
+		if !isAmount {
+			return errors.New("invalid register extension")
+		}
+		a.Reg = arm64.REG_SXTB + Rnum
+	case "SXTH":
+		if !isAmount {
+			return errors.New("invalid register extension")
+		}
+		if a.Type == obj.TYPE_MEM {
+			return errors.New("invalid shift for the register offset addressing mode")
+		}
+		a.Reg = arm64.REG_SXTH + Rnum
+	case "SXTW":
+		if !isAmount {
+			return errors.New("invalid register extension")
+		}
+		if a.Type == obj.TYPE_MEM {
+			a.Index = arm64.REG_SXTW + Rnum
+		} else {
+			a.Reg = arm64.REG_SXTW + Rnum
+		}
+	case "SXTX":
+		if !isAmount {
+			return errors.New("invalid register extension")
+		}
+		if a.Type == obj.TYPE_MEM {
+			a.Index = arm64.REG_SXTX + Rnum
+		} else {
+			a.Reg = arm64.REG_SXTX + Rnum
+		}
+	case "LSL":
+		if !isAmount {
+			return errors.New("invalid register extension")
+		}
+		a.Index = arm64.REG_LSL + Rnum
+	case "B8":
+		if isIndex {
+			return errors.New("invalid register extension")
+		}
+		a.Reg = arm64.REG_ARNG + (reg & 31) + ((arm64.ARNG_8B & 15) << 5)
+	case "B16":
+		if isIndex {
+			return errors.New("invalid register extension")
+		}
+		a.Reg = arm64.REG_ARNG + (reg & 31) + ((arm64.ARNG_16B & 15) << 5)
+	case "H4":
+		if isIndex {
+			return errors.New("invalid register extension")
+		}
+		a.Reg = arm64.REG_ARNG + (reg & 31) + ((arm64.ARNG_4H & 15) << 5)
+	case "H8":
+		if isIndex {
+			return errors.New("invalid register extension")
+		}
+		a.Reg = arm64.REG_ARNG + (reg & 31) + ((arm64.ARNG_8H & 15) << 5)
+	case "S2":
+		if isIndex {
+			return errors.New("invalid register extension")
+		}
+		a.Reg = arm64.REG_ARNG + (reg & 31) + ((arm64.ARNG_2S & 15) << 5)
+	case "S4":
+		if isIndex {
+			return errors.New("invalid register extension")
+		}
+		a.Reg = arm64.REG_ARNG + (reg & 31) + ((arm64.ARNG_4S & 15) << 5)
+	case "D1":
+		if isIndex {
+			return errors.New("invalid register extension")
+		}
+		a.Reg = arm64.REG_ARNG + (reg & 31) + ((arm64.ARNG_1D & 15) << 5)
+	case "D2":
+		if isIndex {
+			return errors.New("invalid register extension")
+		}
+		a.Reg = arm64.REG_ARNG + (reg & 31) + ((arm64.ARNG_2D & 15) << 5)
+	case "Q1":
+		if isIndex {
+			return errors.New("invalid register extension")
+		}
+		a.Reg = arm64.REG_ARNG + (reg & 31) + ((arm64.ARNG_1Q & 15) << 5)
+	case "B":
+		if !isIndex {
+			return nil
+		}
+		a.Reg = arm64.REG_ELEM + (reg & 31) + ((arm64.ARNG_B & 15) << 5)
+		a.Index = num
+	case "H":
+		if !isIndex {
+			return nil
+		}
+		a.Reg = arm64.REG_ELEM + (reg & 31) + ((arm64.ARNG_H & 15) << 5)
+		a.Index = num
+	case "S":
+		if !isIndex {
+			return nil
+		}
+		a.Reg = arm64.REG_ELEM + (reg & 31) + ((arm64.ARNG_S & 15) << 5)
+		a.Index = num
+	case "D":
+		if !isIndex {
+			return nil
+		}
+		a.Reg = arm64.REG_ELEM + (reg & 31) + ((arm64.ARNG_D & 15) << 5)
+		a.Index = num
+	default:
+		return errors.New("unsupported register extension type: " + ext)
 	}
+
 	return nil
 }

-// ARM64RegisterArrangement constructs an ARM64 vector register arrangement.
+// ARM64RegisterArrangement parses an ARM64 vector register arrangement.
 func ARM64RegisterArrangement(reg int16, name, arng string) (int64, error) {
 	var curQ, curSize uint16
 	if name[0] != 'V' {
--- a/src/cmd/asm/internal/asm/asm.go
+++ b/src/cmd/asm/internal/asm/asm.go
@@ -134,14 +134,6 @@ func (p *Parser) asmText(operands [][]lex.Token) {
 		next++
 	}

-	// Issue an error if we see a function defined as ABIInternal
-	// without NOSPLIT. In ABIInternal, obj needs to know the function
-	// signature in order to construct the morestack path, so this
-	// currently isn't supported for asm functions.
-	if nameAddr.Sym.ABI() == obj.ABIInternal && flag&obj.NOSPLIT == 0 {
-		p.errorf("TEXT %q: ABIInternal requires NOSPLIT", name)
-	}
-
 	// Next operand is the frame and arg size.
 	// Bizarre syntax: $frameSize-argSize is two words, not subtraction.
 	// Both frameSize and argSize must be simple integers; only frameSize
@@ -807,11 +799,22 @@ func (p *Parser) asmInstruction(op obj.As, cond string, a []obj.Addr) {
 		p.errorf("can't handle %s instruction with 4 operands", op)
 		return
 	case 5:
-		if p.arch.Family == sys.PPC64 {
+		if p.arch.Family == sys.PPC64 && arch.IsPPC64RLD(op) {
+			// Always reg, reg, con, con, reg.  (con, con is a 'mask').
 			prog.From = a[0]
-			// Second arg is always a register type on ppc64.
 			prog.Reg = p.getRegister(prog, op, &a[1])
-			prog.SetRestArgs([]obj.Addr{a[2], a[3]})
+			mask1 := p.getConstant(prog, op, &a[2])
+			mask2 := p.getConstant(prog, op, &a[3])
+			var mask uint32
+			if mask1 < mask2 {
+				mask = (^uint32(0) >> uint(mask1)) & (^uint32(0) << uint(31-mask2))
+			} else {
+				mask = (^uint32(0) >> uint(mask2+1)) & (^uint32(0) << uint(31-(mask1-1)))
+			}
+			prog.SetFrom3(obj.Addr{
+				Type:   obj.TYPE_CONST,
+				Offset: int64(mask),
+			})
 			prog.To = a[4]
 			break
 		}
--- a/src/cmd/asm/internal/asm/endtoend_test.go
+++ b/src/cmd/asm/internal/asm/endtoend_test.go
@@ -8,7 +8,6 @@ import (
 	"bufio"
 	"bytes"
 	"fmt"
-	"internal/buildcfg"
 	"io/ioutil"
 	"os"
 	"path/filepath"
@@ -20,6 +19,7 @@ import (

 	"cmd/asm/internal/lex"
 	"cmd/internal/obj"
+	"cmd/internal/objabi"
 )

 // An end-to-end test for the assembler: Do we print what we parse?
@@ -36,7 +36,6 @@ func testEndToEnd(t *testing.T, goarch, file string) {
 	var ok bool
 	testOut = new(bytes.Buffer) // The assembler writes test output to this buffer.
 	ctxt.Bso = bufio.NewWriter(os.Stdout)
-	ctxt.IsAsm = true
 	defer ctxt.Bso.Flush()
 	failed := false
 	ctxt.DiagFunc = func(format string, args ...interface{}) {
@@ -270,7 +269,7 @@ var (
 	errQuotesRE = regexp.MustCompile(`"([^"]*)"`)
 )

-func testErrors(t *testing.T, goarch, file string, flags ...string) {
+func testErrors(t *testing.T, goarch, file string) {
 	input := filepath.Join("testdata", file+".s")
 	architecture, ctxt := setArch(goarch)
 	lexer := lex.NewLexer(input)
@@ -279,7 +278,6 @@ func testErrors(t *testing.T, goarch, file string, flags ...string) {
 	var ok bool
 	testOut = new(bytes.Buffer) // The assembler writes test output to this buffer.
 	ctxt.Bso = bufio.NewWriter(os.Stdout)
-	ctxt.IsAsm = true
 	defer ctxt.Bso.Flush()
 	failed := false
 	var errBuf bytes.Buffer
@@ -292,14 +290,6 @@ func testErrors(t *testing.T, goarch, file string, flags ...string) {
 		}
 		errBuf.WriteString(s)
 	}
-	for _, flag := range flags {
-		switch flag {
-		case "dynlink":
-			ctxt.Flag_dynlink = true
-		default:
-			t.Errorf("unknown flag %s", flag)
-		}
-	}
 	pList.Firstpc, ok = parser.Parse()
 	obj.Flushplist(ctxt, pList, nil, "")
 	if ok && !failed {
@@ -368,10 +358,10 @@ func Test386EndToEnd(t *testing.T) {
 }

 func TestARMEndToEnd(t *testing.T) {
-	defer func(old int) { buildcfg.GOARM = old }(buildcfg.GOARM)
+	defer func(old int) { objabi.GOARM = old }(objabi.GOARM)
 	for _, goarm := range []int{5, 6, 7} {
 		t.Logf("GOARM=%d", goarm)
-		buildcfg.GOARM = goarm
+		objabi.GOARM = goarm
 		testEndToEnd(t, "arm", "arm")
 		if goarm == 6 {
 			testEndToEnd(t, "arm", "armv6")
@@ -438,10 +428,6 @@ func TestAMD64Errors(t *testing.T) {
 	testErrors(t, "amd64", "amd64error")
 }

-func TestAMD64DynLinkErrors(t *testing.T) {
-	testErrors(t, "amd64", "amd64dynlinkerror", "dynlink")
-}
-
 func TestMIPSEndToEnd(t *testing.T) {
 	testEndToEnd(t, "mips", "mips")
 	testEndToEnd(t, "mips64", "mips64")
@@ -451,12 +437,8 @@ func TestPPC64EndToEnd(t *testing.T) {
 	testEndToEnd(t, "ppc64", "ppc64")
 }

-func TestRISCVEndToEnd(t *testing.T) {
-	testEndToEnd(t, "riscv64", "riscv64")
-}
-
-func TestRISCVErrors(t *testing.T) {
-	testErrors(t, "riscv64", "riscv64error")
+func TestRISCVEncoder(t *testing.T) {
+	testEndToEnd(t, "riscv64", "riscvenc")
 }

 func TestS390XEndToEnd(t *testing.T) {
--- a/src/cmd/asm/internal/asm/operand_test.go
+++ b/src/cmd/asm/internal/asm/operand_test.go
@@ -5,20 +5,20 @@
 package asm

 import (
-	"internal/buildcfg"
 	"strings"
 	"testing"

 	"cmd/asm/internal/arch"
 	"cmd/asm/internal/lex"
 	"cmd/internal/obj"
+	"cmd/internal/objabi"
 )

 // A simple in-out test: Do we print what we parse?

 func setArch(goarch string) (*arch.Arch, *obj.Link) {
-	buildcfg.GOOS = "linux" // obj can handle this OS for all architectures.
-	buildcfg.GOARCH = goarch
+	objabi.GOOS = "linux" // obj can handle this OS for all architectures.
+	objabi.GOARCH = goarch
 	architecture := arch.Set(goarch)
 	if architecture == nil {
 		panic("asm: unrecognized architecture " + goarch)
@@ -259,7 +259,6 @@ var amd64OperandTests = []operandTest{
 	{"R15", "R15"},
 	{"R8", "R8"},
 	{"R9", "R9"},
-	{"g", "R14"},
 	{"SI", "SI"},
 	{"SP", "SP"},
 	{"X0", "X0"},
--- a/src/cmd/asm/internal/asm/parse.go
+++ b/src/cmd/asm/internal/asm/parse.go
@@ -305,7 +305,7 @@ func (p *Parser) pseudo(word string, operands [][]lex.Token) bool {
 // references and writes symabis information to w.
 //
 // The symabis format is documented at
-// cmd/compile/internal/ssagen.ReadSymABIs.
+// cmd/compile/internal/gc.readSymABIs.
 func (p *Parser) symDefRef(w io.Writer, word string, operands [][]lex.Token) {
 	switch word {
 	case "TEXT":
@@ -689,11 +689,7 @@ func (p *Parser) registerShift(name string, prefix rune) int64 {
 		p.errorf("unexpected %s in register shift", tok.String())
 	}
 	if p.arch.Family == sys.ARM64 {
-		off, err := arch.ARM64RegisterShift(r1, op, count)
-		if err != nil {
-			p.errorf(err.Error())
-		}
-		return off
+		return int64(r1&31)<<16 | int64(op)<<22 | int64(uint16(count))
 	} else {
 		return int64((r1 & 15) | op<<5 | count)
 	}
@@ -1003,18 +999,15 @@ func (p *Parser) registerIndirect(a *obj.Addr, prefix rune) {
 				p.errorf("unimplemented two-register form")
 			}
 			a.Index = r1
-			if scale != 0 && scale != 1 && p.arch.Family == sys.ARM64 {
-				// Support (R1)(R2) (no scaling) and (R1)(R2*1).
-				p.errorf("arm64 doesn't support scaled register format")
+			if scale == 0 && p.arch.Family == sys.ARM64 {
+				// scale is 1 by default for ARM64
+				a.Scale = 1
 			} else {
 				a.Scale = int16(scale)
 			}
 		}
 		p.get(')')
 	} else if scale != 0 {
-		if p.arch.Family == sys.ARM64 {
-			p.errorf("arm64 doesn't support scaled register format")
-		}
 		// First (R) was missing, all we have is (R*scale).
 		a.Reg = 0
 		a.Index = r1
--- a/Show More
+++ b/Show More
Author	SHA1	Message	Date
Alexander Rakoczy	e9e0473681	[release-branch.go1.16-security] go1.16.1 Change-Id: I4999d72caf9462554a2a6f1d761244cafec34718 Reviewed-on: https://team-review.git.corp.google.com/c/golang/go-private/+/1014541 Reviewed-by: Katie Hockman <katiehockman@google.com>	2021-03-10 14:25:03 +00:00
Roland Shoemaker	634d28d78c	[release-branch.go1.16-security] archive/zip: fix panic in Reader.Open When operating on a Zip file that contains a file prefixed with "../", Open(...) would cause a panic in toValidName when attempting to strip the prefixed path components. Fixes CVE-2021-27919 Change-Id: Ic755d8126cb0897e2cbbdacf572439c38dde7b35 Reviewed-on: https://team-review.git.corp.google.com/c/golang/go-private/+/1004761 Reviewed-by: Filippo Valsorda <valsorda@google.com> Reviewed-by: Russ Cox <rsc@google.com> Reviewed-by: Katie Hockman <katiehockman@google.com> (cherry picked from commit ce22003b26eaf8e4a690757f699aae7062d41472) Reviewed-on: https://team-review.git.corp.google.com/c/golang/go-private/+/1013753 Reviewed-by: Roland Shoemaker <bracewell@google.com>	2021-03-09 17:55:16 +00:00
Katie Hockman	d86e53e896	[release-branch.go1.16-security] encoding/xml: prevent infinite loop while decoding This change properly handles a TokenReader which returns an EOF in the middle of an open XML element. Thanks to Sam Whited for reporting this. Fixes CVE-2021-27918 Change-Id: Id02a3f3def4a1b415fa2d9a8e3b373eb6cb0f433 Reviewed-on: https://team-review.git.corp.google.com/c/golang/go-private/+/1004594 Reviewed-by: Russ Cox <rsc@google.com> Reviewed-by: Roland Shoemaker <bracewell@google.com> Reviewed-by: Filippo Valsorda <valsorda@google.com> (cherry picked from commit e7ce1f6746223ec7b4caa3b1ece25d9be3864710) Reviewed-on: https://team-review.git.corp.google.com/c/golang/go-private/+/1014235	2021-03-09 17:55:05 +00:00
Alexander Rakoczy	f21be2fdc6	[release-branch.go1.16] go1.16 Change-Id: I4c1350e0cb74ebfde5832973979e02997476d16c Reviewed-on: https://go-review.googlesource.com/c/go/+/292609 TryBot-Result: Go Bot <gobot@golang.org> Trust: Alexander Rakoczy <alex@golang.org> Run-TryBot: Alexander Rakoczy <alex@golang.org> Reviewed-by: Dmitri Shuralyov <dmitshur@golang.org> Reviewed-by: Carlos Amedee <carlos@golang.org>	2021-02-16 18:08:40 +00:00
Alexander Rakoczy	e34168e634	[release-branch.go1.16] all: merge master into release-branch.go1.16 `1004a7cb31` runtime/metrics: update documentation to current interface `6530f2617f` doc/go1.16: remove draft notice `353e111455` doc/go1.16: fix mismatched id attribute `f0d23c9dbb` internal/poll: netpollcheckerr before sendfile `0cb3415154` doc: remove all docs not tied to distribution `626ef08127` doc: remove install.html and install-source.html `30641e36aa` internal/poll: if copy_file_range returns 0, assume it failed `33d72fd412` doc/faq: update generics entry to reflect accepted proposal `852ce7c212` cmd/go: provide a more helpful suggestion for "go vet -?" `66c27093d0` cmd/link: fix typo in link_test.go `ff0e93ea31` doc/go1.16: note that package path elements beginning with '.' are disallowed `249da7ec02` CONTRIBUTORS: update for the Go 1.16 release `864d4f1c6b` cmd/go: multiple small 'go help' fixes `26ceae85a8` spec: More precise wording in section on function calls. `930c2c9a68` cmd/go: reject embedded files that can't be packed into modules `e5b08e6d5c` io/fs: allow backslash in ValidPath, reject in os.DirFS.Open `ed8079096f` cmd/compile: mark concrete call of reflect.(*rtype).Method as REFLECTMETHOD `e9c9683597` cmd/go: suppress errors from 'go get -d' for packages that only conditionally exist `e0ac989cf3` archive/tar: detect out of bounds accesses in PAX records resulting from padded lengths `c9d6f45fec` runtime/metrics: fix a couple of documentation typpos `cea4e21b52` io/fs: backslash is always a glob meta character `dc725bfb3c` doc/go1.16: mention new vet check for asn1.Unmarshal `1901853098` runtime/metrics: fix panic in readingAllMetric example `ed3e4afa12` syscall/plan9: remove spooky fd action at a distance `724d0720b3` doc/go1.16: add missed heading tag in vet section `b54cd94d47` embed, io/fs: clarify that leading and trailing slashes are disallowed `4516afebed` testing/fstest: avoid symlink-induced failures in tester `8869086d8f` runtime: fix typo in histogram.go `e491c6eea9` math/big: fix comment in divRecursiveStep `fca94ab3ab` spec: improve the example in Type assertions section `98f8454a73` cmd/link: don't decode type symbol in shared library in deadcode `1426a571b7` cmd/link: fix off-by-1 error in findShlibSection `32e789f4fb` test: fix incorrectly laid out instructions in issue11656.go `0b6cfea634` doc/go1.16: document that on OpenBSD syscalls are now made through libc `26e29aa15a` cmd/link: disable TestPIESize if CGO isn't enabled `6ac91e460c` doc/go1.16: minor markup fixes `44361140c0` embed: update docs for proposal tweaks `68058edc39` runtime: document pointer write atomicity for memclrNoHeapPointers `c8bd8010ff` syscall: generate readlen/writelen for openbsd libc `41bb49b878` cmd/go: revert TestScript/build_trimpath to use ioutil.ReadFile `725a642c2d` runtime: correct syscall10/syscall10X on openbsd/amd64 `4b068cafb5` doc/go1.16: document go/build/constraint package `376518d77f` runtime,syscall: convert syscall on openbsd/arm64 to libc Change-Id: Icfe3d849f459eda48d7d786d0cd7b082c9c2c325	2021-02-16 12:10:50 -05:00
Alexander Rakoczy	3e06467282	[release-branch.go1.16] go1.16rc1 Change-Id: I978f6df491a19a9c45ab906dbc5194b8665bf4a5 Reviewed-on: https://go-review.googlesource.com/c/go/+/287352 Run-TryBot: Alexander Rakoczy <alex@golang.org> Trust: Alexander Rakoczy <alex@golang.org> TryBot-Result: Go Bot <gobot@golang.org> Reviewed-by: Dmitri Shuralyov <dmitshur@golang.org>	2021-01-27 22:19:13 +00:00