build: separate compiler and libs

compiler/internal/lib/time/format_rfc3339.go

@@ -0,0 +1,188 @@
+// Copyright 2022 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 time
+
+import "errors"
+
+// RFC 3339 is the most commonly used format.
+//
+// It is implicitly used by the Time.(Marshal|Unmarshal)(Text|JSON) methods.
+// Also, according to analysis on https://go.dev/issue/52746,
+// RFC 3339 accounts for 57% of all explicitly specified time formats,
+// with the second most popular format only being used 8% of the time.
+// The overwhelming use of RFC 3339 compared to all other formats justifies
+// the addition of logic to optimize formatting and parsing.
+
+func (t Time) appendFormatRFC3339(b []byte, nanos bool) []byte {
+	_, offset, abs := t.locabs()
+
+	// Format date.
+	year, month, day, _ := absDate(abs, true)
+	b = appendInt(b, year, 4)
+	b = append(b, '-')
+	b = appendInt(b, int(month), 2)
+	b = append(b, '-')
+	b = appendInt(b, day, 2)
+
+	b = append(b, 'T')
+
+	// Format time.
+	hour, min, sec := absClock(abs)
+	b = appendInt(b, hour, 2)
+	b = append(b, ':')
+	b = appendInt(b, min, 2)
+	b = append(b, ':')
+	b = appendInt(b, sec, 2)
+
+	if nanos {
+		std := stdFracSecond(stdFracSecond9, 9, '.')
+		b = appendNano(b, t.Nanosecond(), std)
+	}
+
+	if offset == 0 {
+		return append(b, 'Z')
+	}
+
+	// Format zone.
+	zone := offset / 60 // convert to minutes
+	if zone < 0 {
+		b = append(b, '-')
+		zone = -zone
+	} else {
+		b = append(b, '+')
+	}
+	b = appendInt(b, zone/60, 2)
+	b = append(b, ':')
+	b = appendInt(b, zone%60, 2)
+	return b
+}
+
+func (t Time) appendStrictRFC3339(b []byte) ([]byte, error) {
+	n0 := len(b)
+	b = t.appendFormatRFC3339(b, true)
+
+	// Not all valid Go timestamps can be serialized as valid RFC 3339.
+	// Explicitly check for these edge cases.
+	// See https://go.dev/issue/4556 and https://go.dev/issue/54580.
+	num2 := func(b []byte) byte { return 10*(b[0]-'0') + (b[1] - '0') }
+	switch {
+	case b[n0+len("9999")] != '-': // year must be exactly 4 digits wide
+		return b, errors.New("year outside of range [0,9999]")
+	case b[len(b)-1] != 'Z':
+		c := b[len(b)-len("Z07:00")]
+		if ('0' <= c && c <= '9') || num2(b[len(b)-len("07:00"):]) >= 24 {
+			return b, errors.New("timezone hour outside of range [0,23]")
+		}
+	}
+	return b, nil
+}
+
+func parseRFC3339[bytes []byte | string](s bytes, local *Location) (Time, bool) {
+	// parseUint parses s as an unsigned decimal integer and
+	// verifies that it is within some range.
+	// If it is invalid or out-of-range,
+	// it sets ok to false and returns the min value.
+	ok := true
+	parseUint := func(s bytes, min, max int) (x int) {
+		for _, c := range []byte(s) {
+			if c < '0' || '9' < c {
+				ok = false
+				return min
+			}
+			x = x*10 + int(c) - '0'
+		}
+		if x < min || max < x {
+			ok = false
+			return min
+		}
+		return x
+	}
+
+	// Parse the date and time.
+	if len(s) < len("2006-01-02T15:04:05") {
+		return Time{}, false
+	}
+	year := parseUint(s[0:4], 0, 9999)                       // e.g., 2006
+	month := parseUint(s[5:7], 1, 12)                        // e.g., 01
+	day := parseUint(s[8:10], 1, daysIn(Month(month), year)) // e.g., 02
+	hour := parseUint(s[11:13], 0, 23)                       // e.g., 15
+	min := parseUint(s[14:16], 0, 59)                        // e.g., 04
+	sec := parseUint(s[17:19], 0, 59)                        // e.g., 05
+	if !ok || !(s[4] == '-' && s[7] == '-' && s[10] == 'T' && s[13] == ':' && s[16] == ':') {
+		return Time{}, false
+	}
+	s = s[19:]
+
+	// Parse the fractional second.
+	var nsec int
+	if len(s) >= 2 && s[0] == '.' && isDigit(s, 1) {
+		n := 2
+		for ; n < len(s) && isDigit(s, n); n++ {
+		}
+		nsec, _, _ = parseNanoseconds(s, n)
+		s = s[n:]
+	}
+
+	// Parse the time zone.
+	t := Date(year, Month(month), day, hour, min, sec, nsec, UTC)
+	if len(s) != 1 || s[0] != 'Z' {
+		if len(s) != len("-07:00") {
+			return Time{}, false
+		}
+		hr := parseUint(s[1:3], 0, 23) // e.g., 07
+		mm := parseUint(s[4:6], 0, 59) // e.g., 00
+		if !ok || !((s[0] == '-' || s[0] == '+') && s[3] == ':') {
+			return Time{}, false
+		}
+		zoneOffset := (hr*60 + mm) * 60
+		if s[0] == '-' {
+			zoneOffset *= -1
+		}
+		t.addSec(-int64(zoneOffset))
+
+		// Use local zone with the given offset if possible.
+		if _, offset, _, _, _ := local.lookup(t.unixSec()); offset == zoneOffset {
+			t.setLoc(local)
+		} else {
+			t.setLoc(FixedZone("", zoneOffset))
+		}
+	}
+	return t, true
+}
+
+func parseStrictRFC3339(b []byte) (Time, error) {
+	t, ok := parseRFC3339(b, Local)
+	if !ok {
+		t, err := Parse(RFC3339, string(b))
+		if err != nil {
+			return Time{}, err
+		}
+
+		// The parse template syntax cannot correctly validate RFC 3339.
+		// Explicitly check for cases that Parse is unable to validate for.
+		// See https://go.dev/issue/54580.
+		num2 := func(b []byte) byte { return 10*(b[0]-'0') + (b[1] - '0') }
+		switch {
+		// TODO(https://go.dev/issue/54580): Strict parsing is disabled for now.
+		// Enable this again with a GODEBUG opt-out.
+		case true:
+			return t, nil
+		case b[len("2006-01-02T")+1] == ':': // hour must be two digits
+			return Time{}, &ParseError{RFC3339, string(b), "15", string(b[len("2006-01-02T"):][:1]), ""}
+		case b[len("2006-01-02T15:04:05")] == ',': // sub-second separator must be a period
+			return Time{}, &ParseError{RFC3339, string(b), ".", ",", ""}
+		case b[len(b)-1] != 'Z':
+			switch {
+			case num2(b[len(b)-len("07:00"):]) >= 24: // timezone hour must be in range
+				return Time{}, &ParseError{RFC3339, string(b), "Z07:00", string(b[len(b)-len("Z07:00"):]), ": timezone hour out of range"}
+			case num2(b[len(b)-len("00"):]) >= 60: // timezone minute must be in range
+				return Time{}, &ParseError{RFC3339, string(b), "Z07:00", string(b[len(b)-len("Z07:00"):]), ": timezone minute out of range"}
+			}
+		default: // unknown error; should not occur
+			return Time{}, &ParseError{RFC3339, string(b), RFC3339, string(b), ""}
+		}
+	}
+	return t, nil
+}

compiler/internal/lib/time/sleep.go

@@ -0,0 +1,184 @@
+// Copyright 2009 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 time
+
+// Sleep pauses the current goroutine for at least the duration d.
+// A negative or zero duration causes Sleep to return immediately.
+func Sleep(d Duration) {
+	panic("todo: time.Sleep")
+}
+
+// Interface to timers implemented in package runtime.
+// Must be in sync with ../runtime/time.go:/^type timer
+type runtimeTimer struct {
+	pp       uintptr
+	when     int64
+	period   int64
+	f        func(any, uintptr) // NOTE: must not be closure
+	arg      any
+	seq      uintptr
+	nextwhen int64
+	status   uint32
+}
+
+// when is a helper function for setting the 'when' field of a runtimeTimer.
+// It returns what the time will be, in nanoseconds, Duration d in the future.
+// If d is negative, it is ignored. If the returned value would be less than
+// zero because of an overflow, MaxInt64 is returned.
+func when(d Duration) int64 {
+	if d <= 0 {
+		return runtimeNano()
+	}
+	t := runtimeNano() + int64(d)
+	if t < 0 {
+		// N.B. runtimeNano() and d are always positive, so addition
+		// (including overflow) will never result in t == 0.
+		t = 1<<63 - 1 // math.MaxInt64
+	}
+	return t
+}
+
+func startTimer(*runtimeTimer)             { panic("todo: time.startTimer") }
+func stopTimer(*runtimeTimer) bool         { panic("todo: time.stopTimer") }
+func resetTimer(*runtimeTimer, int64) bool { panic("todo: time.resetTimer") }
+
+/* TODO(xsw):
+func modTimer(t *runtimeTimer, when, period int64, f func(any, uintptr), arg any, seq uintptr) {
+	panic("todo: time.modTimer")
+}
+*/
+
+// The Timer type represents a single event.
+// When the Timer expires, the current time will be sent on C,
+// unless the Timer was created by AfterFunc.
+// A Timer must be created with NewTimer or AfterFunc.
+type Timer struct {
+	C <-chan Time
+	r runtimeTimer
+}
+
+// Stop prevents the Timer from firing.
+// It returns true if the call stops the timer, false if the timer has already
+// expired or been stopped.
+// Stop does not close the channel, to prevent a read from the channel succeeding
+// incorrectly.
+//
+// To ensure the channel is empty after a call to Stop, check the
+// return value and drain the channel.
+// For example, assuming the program has not received from t.C already:
+//
+//	if !t.Stop() {
+//		<-t.C
+//	}
+//
+// This cannot be done concurrent to other receives from the Timer's
+// channel or other calls to the Timer's Stop method.
+//
+// For a timer created with AfterFunc(d, f), if t.Stop returns false, then the timer
+// has already expired and the function f has been started in its own goroutine;
+// Stop does not wait for f to complete before returning.
+// If the caller needs to know whether f is completed, it must coordinate
+// with f explicitly.
+func (t *Timer) Stop() bool {
+	if t.r.f == nil {
+		panic("time: Stop called on uninitialized Timer")
+	}
+	return stopTimer(&t.r)
+}
+
+// NewTimer creates a new Timer that will send
+// the current time on its channel after at least duration d.
+func NewTimer(d Duration) *Timer {
+	c := make(chan Time, 1)
+	t := &Timer{
+		C: c,
+		r: runtimeTimer{
+			when: when(d),
+			f:    sendTime,
+			arg:  c,
+		},
+	}
+	startTimer(&t.r)
+	return t
+}
+
+// Reset changes the timer to expire after duration d.
+// It returns true if the timer had been active, false if the timer had
+// expired or been stopped.
+//
+// For a Timer created with NewTimer, Reset should be invoked only on
+// stopped or expired timers with drained channels.
+//
+// If a program has already received a value from t.C, the timer is known
+// to have expired and the channel drained, so t.Reset can be used directly.
+// If a program has not yet received a value from t.C, however,
+// the timer must be stopped and—if Stop reports that the timer expired
+// before being stopped—the channel explicitly drained:
+//
+//	if !t.Stop() {
+//		<-t.C
+//	}
+//	t.Reset(d)
+//
+// This should not be done concurrent to other receives from the Timer's
+// channel.
+//
+// Note that it is not possible to use Reset's return value correctly, as there
+// is a race condition between draining the channel and the new timer expiring.
+// Reset should always be invoked on stopped or expired channels, as described above.
+// The return value exists to preserve compatibility with existing programs.
+//
+// For a Timer created with AfterFunc(d, f), Reset either reschedules
+// when f will run, in which case Reset returns true, or schedules f
+// to run again, in which case it returns false.
+// When Reset returns false, Reset neither waits for the prior f to
+// complete before returning nor does it guarantee that the subsequent
+// goroutine running f does not run concurrently with the prior
+// one. If the caller needs to know whether the prior execution of
+// f is completed, it must coordinate with f explicitly.
+func (t *Timer) Reset(d Duration) bool {
+	if t.r.f == nil {
+		panic("time: Reset called on uninitialized Timer")
+	}
+	w := when(d)
+	return resetTimer(&t.r, w)
+}
+
+// sendTime does a non-blocking send of the current time on c.
+func sendTime(c any, seq uintptr) {
+	select {
+	case c.(chan Time) <- Now():
+	default:
+	}
+}
+
+// After waits for the duration to elapse and then sends the current time
+// on the returned channel.
+// It is equivalent to NewTimer(d).C.
+// The underlying Timer is not recovered by the garbage collector
+// until the timer fires. If efficiency is a concern, use NewTimer
+// instead and call Timer.Stop if the timer is no longer needed.
+func After(d Duration) <-chan Time {
+	return NewTimer(d).C
+}
+
+// AfterFunc waits for the duration to elapse and then calls f
+// in its own goroutine. It returns a Timer that can
+// be used to cancel the call using its Stop method.
+func AfterFunc(d Duration, f func()) *Timer {
+	t := &Timer{
+		r: runtimeTimer{
+			when: when(d),
+			f:    goFunc,
+			arg:  f,
+		},
+	}
+	startTimer(&t.r)
+	return t
+}
+
+func goFunc(arg any, seq uintptr) {
+	go arg.(func())()
+}

compiler/internal/lib/time/sys_unix.go

@@ -0,0 +1,62 @@
+// Copyright 2011 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.
+
+//go:build unix || (js && wasm) || wasip1
+
+package time
+
+import (
+	"errors"
+	"runtime"
+	"syscall"
+)
+
+// for testing: whatever interrupts a sleep
+func interrupt() {
+	// There is no mechanism in wasi to interrupt the call to poll_oneoff
+	// used to implement runtime.usleep so this function does nothing, which
+	// somewhat defeats the purpose of TestSleep but we are still better off
+	// validating that time elapses when the process calls time.Sleep than
+	// skipping the test altogether.
+	if runtime.GOOS != "wasip1" {
+		syscall.Kill(syscall.Getpid(), syscall.SIGCHLD)
+	}
+}
+
+func open(name string) (uintptr, error) {
+	fd, err := syscall.Open(name, syscall.O_RDONLY, 0)
+	if err != nil {
+		return 0, err
+	}
+	return uintptr(fd), nil
+}
+
+func read(fd uintptr, buf []byte) (int, error) {
+	return syscall.Read(int(fd), buf)
+}
+
+func closefd(fd uintptr) {
+	syscall.Close(int(fd))
+}
+
+func preadn(fd uintptr, buf []byte, off int) error {
+	whence := seekStart
+	if off < 0 {
+		whence = seekEnd
+	}
+	if _, err := syscall.Seek(int(fd), int64(off), whence); err != nil {
+		return err
+	}
+	for len(buf) > 0 {
+		m, err := syscall.Read(int(fd), buf)
+		if m <= 0 {
+			if err == nil {
+				return errors.New("short read")
+			}
+			return err
+		}
+		buf = buf[m:]
+	}
+	return nil
+}

compiler/internal/lib/time/zoneinfo.go

@@ -0,0 +1,548 @@
+// Copyright 2011 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 time
+
+import "sync"
+
+// A Location maps time instants to the zone in use at that time.
+// Typically, the Location represents the collection of time offsets
+// in use in a geographical area. For many Locations the time offset varies
+// depending on whether daylight savings time is in use at the time instant.
+type Location struct {
+	name string
+	zone []zone
+	tx   []zoneTrans
+
+	// The tzdata information can be followed by a string that describes
+	// how to handle DST transitions not recorded in zoneTrans.
+	// The format is the TZ environment variable without a colon; see
+	// https://pubs.opengroup.org/onlinepubs/9699919799/basedefs/V1_chap08.html.
+	// Example string, for America/Los_Angeles: PST8PDT,M3.2.0,M11.1.0
+	extend string
+
+	// Most lookups will be for the current time.
+	// To avoid the binary search through tx, keep a
+	// static one-element cache that gives the correct
+	// zone for the time when the Location was created.
+	// if cacheStart <= t < cacheEnd,
+	// lookup can return cacheZone.
+	// The units for cacheStart and cacheEnd are seconds
+	// since January 1, 1970 UTC, to match the argument
+	// to lookup.
+	cacheStart int64
+	cacheEnd   int64
+	cacheZone  *zone
+}
+
+// A zone represents a single time zone such as CET.
+type zone struct {
+	name   string // abbreviated name, "CET"
+	offset int    // seconds east of UTC
+	isDST  bool   // is this zone Daylight Savings Time?
+}
+
+// A zoneTrans represents a single time zone transition.
+type zoneTrans struct {
+	when         int64 // transition time, in seconds since 1970 GMT
+	index        uint8 // the index of the zone that goes into effect at that time
+	isstd, isutc bool  // ignored - no idea what these mean
+}
+
+// alpha and omega are the beginning and end of time for zone
+// transitions.
+const (
+	alpha = -1 << 63  // math.MinInt64
+	omega = 1<<63 - 1 // math.MaxInt64
+)
+
+// UTC represents Universal Coordinated Time (UTC).
+var UTC *Location = &utcLoc
+
+// utcLoc is separate so that get can refer to &utcLoc
+// and ensure that it never returns a nil *Location,
+// even if a badly behaved client has changed UTC.
+var utcLoc = Location{name: "UTC"}
+
+// Local represents the system's local time zone.
+// On Unix systems, Local consults the TZ environment
+// variable to find the time zone to use. No TZ means
+// use the system default /etc/localtime.
+// TZ="" means use UTC.
+// TZ="foo" means use file foo in the system timezone directory.
+var Local *Location = &localLoc
+
+// localLoc is separate so that initLocal can initialize
+// it even if a client has changed Local.
+var localLoc Location
+var localOnce sync.Once
+
+func (l *Location) get() *Location {
+	if l == nil {
+		return &utcLoc
+	}
+	if l == &localLoc {
+		localOnce.Do(initLocal)
+	}
+	return l
+}
+
+// String returns a descriptive name for the time zone information,
+// corresponding to the name argument to LoadLocation or FixedZone.
+func (l *Location) String() string {
+	return l.get().name
+}
+
+var unnamedFixedZones []*Location
+var unnamedFixedZonesOnce sync.Once
+
+// FixedZone returns a Location that always uses
+// the given zone name and offset (seconds east of UTC).
+func FixedZone(name string, offset int) *Location {
+	// Most calls to FixedZone have an unnamed zone with an offset by the hour.
+	// Optimize for that case by returning the same *Location for a given hour.
+	const hoursBeforeUTC = 12
+	const hoursAfterUTC = 14
+	hour := offset / 60 / 60
+	if name == "" && -hoursBeforeUTC <= hour && hour <= +hoursAfterUTC && hour*60*60 == offset {
+		unnamedFixedZonesOnce.Do(func() {
+			unnamedFixedZones = make([]*Location, hoursBeforeUTC+1+hoursAfterUTC)
+			for hr := -hoursBeforeUTC; hr <= +hoursAfterUTC; hr++ {
+				unnamedFixedZones[hr+hoursBeforeUTC] = fixedZone("", hr*60*60)
+			}
+		})
+		return unnamedFixedZones[hour+hoursBeforeUTC]
+	}
+	return fixedZone(name, offset)
+}
+
+func fixedZone(name string, offset int) *Location {
+	l := &Location{
+		name:       name,
+		zone:       []zone{{name, offset, false}},
+		tx:         []zoneTrans{{alpha, 0, false, false}},
+		cacheStart: alpha,
+		cacheEnd:   omega,
+	}
+	l.cacheZone = &l.zone[0]
+	return l
+}
+
+// lookup returns information about the time zone in use at an
+// instant in time expressed as seconds since January 1, 1970 00:00:00 UTC.
+//
+// The returned information gives the name of the zone (such as "CET"),
+// the start and end times bracketing sec when that zone is in effect,
+// the offset in seconds east of UTC (such as -5*60*60), and whether
+// the daylight savings is being observed at that time.
+func (l *Location) lookup(sec int64) (name string, offset int, start, end int64, isDST bool) {
+	l = l.get()
+
+	if len(l.zone) == 0 {
+		name = "UTC"
+		offset = 0
+		start = alpha
+		end = omega
+		isDST = false
+		return
+	}
+
+	if zone := l.cacheZone; zone != nil && l.cacheStart <= sec && sec < l.cacheEnd {
+		name = zone.name
+		offset = zone.offset
+		start = l.cacheStart
+		end = l.cacheEnd
+		isDST = zone.isDST
+		return
+	}
+
+	/*
+		if len(l.tx) == 0 || sec < l.tx[0].when {
+			zone := &l.zone[l.lookupFirstZone()]
+			name = zone.name
+			offset = zone.offset
+			start = alpha
+			if len(l.tx) > 0 {
+				end = l.tx[0].when
+			} else {
+				end = omega
+			}
+			isDST = zone.isDST
+			return
+		}
+
+		// Binary search for entry with largest time <= sec.
+		// Not using sort.Search to avoid dependencies.
+		tx := l.tx
+		end = omega
+		lo := 0
+		hi := len(tx)
+		for hi-lo > 1 {
+			m := lo + (hi-lo)/2
+			lim := tx[m].when
+			if sec < lim {
+				end = lim
+				hi = m
+			} else {
+				lo = m
+			}
+		}
+		zone := &l.zone[tx[lo].index]
+		name = zone.name
+		offset = zone.offset
+		start = tx[lo].when
+		// end = maintained during the search
+		isDST = zone.isDST
+
+		// If we're at the end of the known zone transitions,
+		// try the extend string.
+		if lo == len(tx)-1 && l.extend != "" {
+			if ename, eoffset, estart, eend, eisDST, ok := tzset(l.extend, start, sec); ok {
+				return ename, eoffset, estart, eend, eisDST
+			}
+		}
+
+		return
+	*/
+	panic("todo: Location.lookup")
+}
+
+// tzset takes a timezone string like the one found in the TZ environment
+// variable, the time of the last time zone transition expressed as seconds
+// since January 1, 1970 00:00:00 UTC, and a time expressed the same way.
+// We call this a tzset string since in C the function tzset reads TZ.
+// The return values are as for lookup, plus ok which reports whether the
+// parse succeeded.
+func tzset(s string, lastTxSec, sec int64) (name string, offset int, start, end int64, isDST, ok bool) {
+	var (
+		stdName, dstName     string
+		stdOffset, dstOffset int
+	)
+
+	stdName, s, ok = tzsetName(s)
+	if ok {
+		stdOffset, s, ok = tzsetOffset(s)
+	}
+	if !ok {
+		return "", 0, 0, 0, false, false
+	}
+
+	// The numbers in the tzset string are added to local time to get UTC,
+	// but our offsets are added to UTC to get local time,
+	// so we negate the number we see here.
+	stdOffset = -stdOffset
+
+	if len(s) == 0 || s[0] == ',' {
+		// No daylight savings time.
+		return stdName, stdOffset, lastTxSec, omega, false, true
+	}
+
+	dstName, s, ok = tzsetName(s)
+	if ok {
+		if len(s) == 0 || s[0] == ',' {
+			dstOffset = stdOffset + secondsPerHour
+		} else {
+			dstOffset, s, ok = tzsetOffset(s)
+			dstOffset = -dstOffset // as with stdOffset, above
+		}
+	}
+	if !ok {
+		return "", 0, 0, 0, false, false
+	}
+
+	if len(s) == 0 {
+		// Default DST rules per tzcode.
+		s = ",M3.2.0,M11.1.0"
+	}
+	// The TZ definition does not mention ';' here but tzcode accepts it.
+	if s[0] != ',' && s[0] != ';' {
+		return "", 0, 0, 0, false, false
+	}
+	s = s[1:]
+
+	var startRule, endRule rule
+	startRule, s, ok = tzsetRule(s)
+	if !ok || len(s) == 0 || s[0] != ',' {
+		return "", 0, 0, 0, false, false
+	}
+	s = s[1:]
+	endRule, s, ok = tzsetRule(s)
+	if !ok || len(s) > 0 {
+		return "", 0, 0, 0, false, false
+	}
+
+	year, _, _, yday := absDate(uint64(sec+unixToInternal+internalToAbsolute), false)
+
+	ysec := int64(yday*secondsPerDay) + sec%secondsPerDay
+
+	// Compute start of year in seconds since Unix epoch.
+	d := daysSinceEpoch(year)
+	abs := int64(d * secondsPerDay)
+	abs += absoluteToInternal + internalToUnix
+
+	startSec := int64(tzruleTime(year, startRule, stdOffset))
+	endSec := int64(tzruleTime(year, endRule, dstOffset))
+	dstIsDST, stdIsDST := true, false
+	// Note: this is a flipping of "DST" and "STD" while retaining the labels
+	// This happens in southern hemispheres. The labelling here thus is a little
+	// inconsistent with the goal.
+	if endSec < startSec {
+		startSec, endSec = endSec, startSec
+		stdName, dstName = dstName, stdName
+		stdOffset, dstOffset = dstOffset, stdOffset
+		stdIsDST, dstIsDST = dstIsDST, stdIsDST
+	}
+
+	// The start and end values that we return are accurate
+	// close to a daylight savings transition, but are otherwise
+	// just the start and end of the year. That suffices for
+	// the only caller that cares, which is Date.
+	if ysec < startSec {
+		return stdName, stdOffset, abs, startSec + abs, stdIsDST, true
+	} else if ysec >= endSec {
+		return stdName, stdOffset, endSec + abs, abs + 365*secondsPerDay, stdIsDST, true
+	} else {
+		return dstName, dstOffset, startSec + abs, endSec + abs, dstIsDST, true
+	}
+}
+
+// tzsetName returns the timezone name at the start of the tzset string s,
+// and the remainder of s, and reports whether the parsing is OK.
+func tzsetName(s string) (string, string, bool) {
+	if len(s) == 0 {
+		return "", "", false
+	}
+	if s[0] != '<' {
+		for i, r := range s {
+			switch r {
+			case '0', '1', '2', '3', '4', '5', '6', '7', '8', '9', ',', '-', '+':
+				if i < 3 {
+					return "", "", false
+				}
+				return s[:i], s[i:], true
+			}
+		}
+		if len(s) < 3 {
+			return "", "", false
+		}
+		return s, "", true
+	} else {
+		for i, r := range s {
+			if r == '>' {
+				return s[1:i], s[i+1:], true
+			}
+		}
+		return "", "", false
+	}
+}
+
+// tzsetOffset returns the timezone offset at the start of the tzset string s,
+// and the remainder of s, and reports whether the parsing is OK.
+// The timezone offset is returned as a number of seconds.
+func tzsetOffset(s string) (offset int, rest string, ok bool) {
+	if len(s) == 0 {
+		return 0, "", false
+	}
+	neg := false
+	if s[0] == '+' {
+		s = s[1:]
+	} else if s[0] == '-' {
+		s = s[1:]
+		neg = true
+	}
+
+	// The tzdata code permits values up to 24 * 7 here,
+	// although POSIX does not.
+	var hours int
+	hours, s, ok = tzsetNum(s, 0, 24*7)
+	if !ok {
+		return 0, "", false
+	}
+	off := hours * secondsPerHour
+	if len(s) == 0 || s[0] != ':' {
+		if neg {
+			off = -off
+		}
+		return off, s, true
+	}
+
+	var mins int
+	mins, s, ok = tzsetNum(s[1:], 0, 59)
+	if !ok {
+		return 0, "", false
+	}
+	off += mins * secondsPerMinute
+	if len(s) == 0 || s[0] != ':' {
+		if neg {
+			off = -off
+		}
+		return off, s, true
+	}
+
+	var secs int
+	secs, s, ok = tzsetNum(s[1:], 0, 59)
+	if !ok {
+		return 0, "", false
+	}
+	off += secs
+
+	if neg {
+		off = -off
+	}
+	return off, s, true
+}
+
+// ruleKind is the kinds of rules that can be seen in a tzset string.
+type ruleKind int
+
+const (
+	ruleJulian ruleKind = iota
+	ruleDOY
+	ruleMonthWeekDay
+)
+
+// rule is a rule read from a tzset string.
+type rule struct {
+	kind ruleKind
+	day  int
+	week int
+	mon  int
+	time int // transition time
+}
+
+// tzsetRule parses a rule from a tzset string.
+// It returns the rule, and the remainder of the string, and reports success.
+func tzsetRule(s string) (rule, string, bool) {
+	var r rule
+	if len(s) == 0 {
+		return rule{}, "", false
+	}
+	ok := false
+	if s[0] == 'J' {
+		var jday int
+		jday, s, ok = tzsetNum(s[1:], 1, 365)
+		if !ok {
+			return rule{}, "", false
+		}
+		r.kind = ruleJulian
+		r.day = jday
+	} else if s[0] == 'M' {
+		var mon int
+		mon, s, ok = tzsetNum(s[1:], 1, 12)
+		if !ok || len(s) == 0 || s[0] != '.' {
+			return rule{}, "", false
+
+		}
+		var week int
+		week, s, ok = tzsetNum(s[1:], 1, 5)
+		if !ok || len(s) == 0 || s[0] != '.' {
+			return rule{}, "", false
+		}
+		var day int
+		day, s, ok = tzsetNum(s[1:], 0, 6)
+		if !ok {
+			return rule{}, "", false
+		}
+		r.kind = ruleMonthWeekDay
+		r.day = day
+		r.week = week
+		r.mon = mon
+	} else {
+		var day int
+		day, s, ok = tzsetNum(s, 0, 365)
+		if !ok {
+			return rule{}, "", false
+		}
+		r.kind = ruleDOY
+		r.day = day
+	}
+
+	if len(s) == 0 || s[0] != '/' {
+		r.time = 2 * secondsPerHour // 2am is the default
+		return r, s, true
+	}
+
+	offset, s, ok := tzsetOffset(s[1:])
+	if !ok {
+		return rule{}, "", false
+	}
+	r.time = offset
+
+	return r, s, true
+}
+
+// tzsetNum parses a number from a tzset string.
+// It returns the number, and the remainder of the string, and reports success.
+// The number must be between min and max.
+func tzsetNum(s string, min, max int) (num int, rest string, ok bool) {
+	if len(s) == 0 {
+		return 0, "", false
+	}
+	num = 0
+	for i, r := range s {
+		if r < '0' || r > '9' {
+			if i == 0 || num < min {
+				return 0, "", false
+			}
+			return num, s[i:], true
+		}
+		num *= 10
+		num += int(r) - '0'
+		if num > max {
+			return 0, "", false
+		}
+	}
+	if num < min {
+		return 0, "", false
+	}
+	return num, "", true
+}
+
+// tzruleTime takes a year, a rule, and a timezone offset,
+// and returns the number of seconds since the start of the year
+// that the rule takes effect.
+func tzruleTime(year int, r rule, off int) int {
+	var s int
+	switch r.kind {
+	case ruleJulian:
+		s = (r.day - 1) * secondsPerDay
+		if isLeap(year) && r.day >= 60 {
+			s += secondsPerDay
+		}
+	case ruleDOY:
+		s = r.day * secondsPerDay
+	case ruleMonthWeekDay:
+		// Zeller's Congruence.
+		m1 := (r.mon+9)%12 + 1
+		yy0 := year
+		if r.mon <= 2 {
+			yy0--
+		}
+		yy1 := yy0 / 100
+		yy2 := yy0 % 100
+		dow := ((26*m1-2)/10 + 1 + yy2 + yy2/4 + yy1/4 - 2*yy1) % 7
+		if dow < 0 {
+			dow += 7
+		}
+		// Now dow is the day-of-week of the first day of r.mon.
+		// Get the day-of-month of the first "dow" day.
+		d := r.day - dow
+		if d < 0 {
+			d += 7
+		}
+		for i := 1; i < r.week; i++ {
+			if d+7 >= daysIn(Month(r.mon), year) {
+				break
+			}
+			d += 7
+		}
+		d += int(daysBefore[r.mon-1])
+		if isLeap(year) && r.mon > 2 {
+			d++
+		}
+		s = d * secondsPerDay
+	}
+
+	return s + r.time - off
+}

compiler/internal/lib/time/zoneinfo_read.go

@@ -0,0 +1,612 @@
+// Copyright 2009 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.
+
+// Parse "zoneinfo" time zone file.
+// This is a fairly standard file format used on OS X, Linux, BSD, Sun, and others.
+// See tzfile(5), https://en.wikipedia.org/wiki/Zoneinfo,
+// and ftp://munnari.oz.au/pub/oldtz/
+
+package time
+
+import (
+	"errors"
+	"runtime"
+	"syscall"
+
+	"github.com/goplus/llgo/c/time"
+)
+
+// registerLoadFromEmbeddedTZData is called by the time/tzdata package,
+// if it is imported.
+func registerLoadFromEmbeddedTZData(f func(string) (string, error)) {
+	loadFromEmbeddedTZData = f
+}
+
+// loadFromEmbeddedTZData is used to load a specific tzdata file
+// from tzdata information embedded in the binary itself.
+// This is set when the time/tzdata package is imported,
+// via registerLoadFromEmbeddedTzdata.
+var loadFromEmbeddedTZData func(zipname string) (string, error)
+
+// maxFileSize is the max permitted size of files read by readFile.
+// As reference, the zoneinfo.zip distributed by Go is ~350 KB,
+// so 10MB is overkill.
+const maxFileSize = 10 << 20
+
+type fileSizeError string
+
+func (f fileSizeError) Error() string {
+	return "time: file " + string(f) + " is too large"
+}
+
+// Copies of io.Seek* constants to avoid importing "io":
+const (
+	seekStart   = 0
+	seekCurrent = 1
+	seekEnd     = 2
+)
+
+// Simple I/O interface to binary blob of data.
+type dataIO struct {
+	p     []byte
+	error bool
+}
+
+func (d *dataIO) read(n int) []byte {
+	if len(d.p) < n {
+		d.p = nil
+		d.error = true
+		return nil
+	}
+	p := d.p[0:n]
+	d.p = d.p[n:]
+	return p
+}
+
+func (d *dataIO) big4() (n uint32, ok bool) {
+	p := d.read(4)
+	if len(p) < 4 {
+		d.error = true
+		return 0, false
+	}
+	return uint32(p[3]) | uint32(p[2])<<8 | uint32(p[1])<<16 | uint32(p[0])<<24, true
+}
+
+func (d *dataIO) big8() (n uint64, ok bool) {
+	n1, ok1 := d.big4()
+	n2, ok2 := d.big4()
+	if !ok1 || !ok2 {
+		d.error = true
+		return 0, false
+	}
+	return (uint64(n1) << 32) | uint64(n2), true
+}
+
+func (d *dataIO) byte() (n byte, ok bool) {
+	p := d.read(1)
+	if len(p) < 1 {
+		d.error = true
+		return 0, false
+	}
+	return p[0], true
+}
+
+// read returns the read of the data in the buffer.
+func (d *dataIO) rest() []byte {
+	r := d.p
+	d.p = nil
+	return r
+}
+
+// Make a string by stopping at the first NUL
+func byteString(p []byte) string {
+	for i := 0; i < len(p); i++ {
+		if p[i] == 0 {
+			return string(p[0:i])
+		}
+	}
+	return string(p)
+}
+
+var errBadData = errors.New("malformed time zone information")
+
+// LoadLocationFromTZData returns a Location with the given name
+// initialized from the IANA Time Zone database-formatted data.
+// The data should be in the format of a standard IANA time zone file
+// (for example, the content of /etc/localtime on Unix systems).
+func LoadLocationFromTZData(name string, data []byte) (*Location, error) {
+	d := dataIO{data, false}
+
+	// 4-byte magic "TZif"
+	if magic := d.read(4); string(magic) != "TZif" {
+		return nil, errBadData
+	}
+
+	// 1-byte version, then 15 bytes of padding
+	var version int
+	var p []byte
+	if p = d.read(16); len(p) != 16 {
+		return nil, errBadData
+	} else {
+		switch p[0] {
+		case 0:
+			version = 1
+		case '2':
+			version = 2
+		case '3':
+			version = 3
+		default:
+			return nil, errBadData
+		}
+	}
+
+	// six big-endian 32-bit integers:
+	//	number of UTC/local indicators
+	//	number of standard/wall indicators
+	//	number of leap seconds
+	//	number of transition times
+	//	number of local time zones
+	//	number of characters of time zone abbrev strings
+	const (
+		NUTCLocal = iota
+		NStdWall
+		NLeap
+		NTime
+		NZone
+		NChar
+	)
+	var n [6]int
+	for i := 0; i < 6; i++ {
+		nn, ok := d.big4()
+		if !ok {
+			return nil, errBadData
+		}
+		if uint32(int(nn)) != nn {
+			return nil, errBadData
+		}
+		n[i] = int(nn)
+	}
+
+	// If we have version 2 or 3, then the data is first written out
+	// in a 32-bit format, then written out again in a 64-bit format.
+	// Skip the 32-bit format and read the 64-bit one, as it can
+	// describe a broader range of dates.
+
+	is64 := false
+	if version > 1 {
+		// Skip the 32-bit data.
+		skip := n[NTime]*4 +
+			n[NTime] +
+			n[NZone]*6 +
+			n[NChar] +
+			n[NLeap]*8 +
+			n[NStdWall] +
+			n[NUTCLocal]
+		// Skip the version 2 header that we just read.
+		skip += 4 + 16
+		d.read(skip)
+
+		is64 = true
+
+		// Read the counts again, they can differ.
+		for i := 0; i < 6; i++ {
+			nn, ok := d.big4()
+			if !ok {
+				return nil, errBadData
+			}
+			if uint32(int(nn)) != nn {
+				return nil, errBadData
+			}
+			n[i] = int(nn)
+		}
+	}
+
+	size := 4
+	if is64 {
+		size = 8
+	}
+
+	// Transition times.
+	txtimes := dataIO{d.read(n[NTime] * size), false}
+
+	// Time zone indices for transition times.
+	txzones := d.read(n[NTime])
+
+	// Zone info structures
+	zonedata := dataIO{d.read(n[NZone] * 6), false}
+
+	// Time zone abbreviations.
+	abbrev := d.read(n[NChar])
+
+	// Leap-second time pairs
+	d.read(n[NLeap] * (size + 4))
+
+	// Whether tx times associated with local time types
+	// are specified as standard time or wall time.
+	isstd := d.read(n[NStdWall])
+
+	// Whether tx times associated with local time types
+	// are specified as UTC or local time.
+	isutc := d.read(n[NUTCLocal])
+
+	if d.error { // ran out of data
+		return nil, errBadData
+	}
+
+	var extend string
+	rest := d.rest()
+	if len(rest) > 2 && rest[0] == '\n' && rest[len(rest)-1] == '\n' {
+		extend = string(rest[1 : len(rest)-1])
+	}
+
+	// Now we can build up a useful data structure.
+	// First the zone information.
+	//	utcoff[4] isdst[1] nameindex[1]
+	nzone := n[NZone]
+	if nzone == 0 {
+		// Reject tzdata files with no zones. There's nothing useful in them.
+		// This also avoids a panic later when we add and then use a fake transition (golang.org/issue/29437).
+		return nil, errBadData
+	}
+	zones := make([]zone, nzone)
+	for i := range zones {
+		var ok bool
+		var n uint32
+		if n, ok = zonedata.big4(); !ok {
+			return nil, errBadData
+		}
+		if uint32(int(n)) != n {
+			return nil, errBadData
+		}
+		zones[i].offset = int(int32(n))
+		var b byte
+		if b, ok = zonedata.byte(); !ok {
+			return nil, errBadData
+		}
+		zones[i].isDST = b != 0
+		if b, ok = zonedata.byte(); !ok || int(b) >= len(abbrev) {
+			return nil, errBadData
+		}
+		zones[i].name = byteString(abbrev[b:])
+		if runtime.GOOS == "aix" && len(name) > 8 && (name[:8] == "Etc/GMT+" || name[:8] == "Etc/GMT-") {
+			// There is a bug with AIX 7.2 TL 0 with files in Etc,
+			// GMT+1 will return GMT-1 instead of GMT+1 or -01.
+			if name != "Etc/GMT+0" {
+				// GMT+0 is OK
+				zones[i].name = name[4:]
+			}
+		}
+	}
+
+	// Now the transition time info.
+	tx := make([]zoneTrans, n[NTime])
+	for i := range tx {
+		var n int64
+		if !is64 {
+			if n4, ok := txtimes.big4(); !ok {
+				return nil, errBadData
+			} else {
+				n = int64(int32(n4))
+			}
+		} else {
+			if n8, ok := txtimes.big8(); !ok {
+				return nil, errBadData
+			} else {
+				n = int64(n8)
+			}
+		}
+		tx[i].when = n
+		if int(txzones[i]) >= len(zones) {
+			return nil, errBadData
+		}
+		tx[i].index = txzones[i]
+		if i < len(isstd) {
+			tx[i].isstd = isstd[i] != 0
+		}
+		if i < len(isutc) {
+			tx[i].isutc = isutc[i] != 0
+		}
+	}
+
+	if len(tx) == 0 {
+		// Build fake transition to cover all time.
+		// This happens in fixed locations like "Etc/GMT0".
+		tx = append(tx, zoneTrans{when: alpha, index: 0})
+	}
+
+	// Committed to succeed.
+	l := &Location{zone: zones, tx: tx, name: name, extend: extend}
+
+	// Fill in the cache with information about right now,
+	// since that will be the most common lookup.
+	sec := nowSec()
+	for i := range tx {
+		if tx[i].when <= sec && (i+1 == len(tx) || sec < tx[i+1].when) {
+			l.cacheStart = tx[i].when
+			l.cacheEnd = omega
+			l.cacheZone = &l.zone[tx[i].index]
+			if i+1 < len(tx) {
+				l.cacheEnd = tx[i+1].when
+			} else if l.extend != "" {
+				// If we're at the end of the known zone transitions,
+				// try the extend string.
+				if name, offset, estart, eend, isDST, ok := tzset(l.extend, l.cacheStart, sec); ok {
+					l.cacheStart = estart
+					l.cacheEnd = eend
+					// Find the zone that is returned by tzset to avoid allocation if possible.
+					if zoneIdx := findZone(l.zone, name, offset, isDST); zoneIdx != -1 {
+						l.cacheZone = &l.zone[zoneIdx]
+					} else {
+						l.cacheZone = &zone{
+							name:   name,
+							offset: offset,
+							isDST:  isDST,
+						}
+					}
+				}
+			}
+			break
+		}
+	}
+
+	return l, nil
+}
+
+func findZone(zones []zone, name string, offset int, isDST bool) int {
+	for i, z := range zones {
+		if z.name == name && z.offset == offset && z.isDST == isDST {
+			return i
+		}
+	}
+	return -1
+}
+
+// loadTzinfoFromDirOrZip returns the contents of the file with the given name
+// in dir. dir can either be an uncompressed zip file, or a directory.
+func loadTzinfoFromDirOrZip(dir, name string) ([]byte, error) {
+	if len(dir) > 4 && dir[len(dir)-4:] == ".zip" {
+		return loadTzinfoFromZip(dir, name)
+	}
+	if dir != "" {
+		name = dir + "/" + name
+	}
+	return readFile(name)
+}
+
+// There are 500+ zoneinfo files. Rather than distribute them all
+// individually, we ship them in an uncompressed zip file.
+// Used this way, the zip file format serves as a commonly readable
+// container for the individual small files. We choose zip over tar
+// because zip files have a contiguous table of contents, making
+// individual file lookups faster, and because the per-file overhead
+// in a zip file is considerably less than tar's 512 bytes.
+
+// get4 returns the little-endian 32-bit value in b.
+func get4(b []byte) int {
+	if len(b) < 4 {
+		return 0
+	}
+	return int(b[0]) | int(b[1])<<8 | int(b[2])<<16 | int(b[3])<<24
+}
+
+// get2 returns the little-endian 16-bit value in b.
+func get2(b []byte) int {
+	if len(b) < 2 {
+		return 0
+	}
+	return int(b[0]) | int(b[1])<<8
+}
+
+// loadTzinfoFromZip returns the contents of the file with the given name
+// in the given uncompressed zip file.
+func loadTzinfoFromZip(zipfile, name string) ([]byte, error) {
+	fd, err := open(zipfile)
+	if err != nil {
+		return nil, err
+	}
+	defer closefd(fd)
+
+	const (
+		zecheader = 0x06054b50
+		zcheader  = 0x02014b50
+		ztailsize = 22
+
+		zheadersize = 30
+		zheader     = 0x04034b50
+	)
+
+	buf := make([]byte, ztailsize)
+	if err := preadn(fd, buf, -ztailsize); err != nil || get4(buf) != zecheader {
+		return nil, errors.New("corrupt zip file " + zipfile)
+	}
+	n := get2(buf[10:])
+	size := get4(buf[12:])
+	off := get4(buf[16:])
+
+	buf = make([]byte, size)
+	if err := preadn(fd, buf, off); err != nil {
+		return nil, errors.New("corrupt zip file " + zipfile)
+	}
+
+	for i := 0; i < n; i++ {
+		// zip entry layout:
+		//	0	magic[4]
+		//	4	madevers[1]
+		//	5	madeos[1]
+		//	6	extvers[1]
+		//	7	extos[1]
+		//	8	flags[2]
+		//	10	meth[2]
+		//	12	modtime[2]
+		//	14	moddate[2]
+		//	16	crc[4]
+		//	20	csize[4]
+		//	24	uncsize[4]
+		//	28	namelen[2]
+		//	30	xlen[2]
+		//	32	fclen[2]
+		//	34	disknum[2]
+		//	36	iattr[2]
+		//	38	eattr[4]
+		//	42	off[4]
+		//	46	name[namelen]
+		//	46+namelen+xlen+fclen - next header
+		//
+		if get4(buf) != zcheader {
+			break
+		}
+		meth := get2(buf[10:])
+		size := get4(buf[24:])
+		namelen := get2(buf[28:])
+		xlen := get2(buf[30:])
+		fclen := get2(buf[32:])
+		off := get4(buf[42:])
+		zname := buf[46 : 46+namelen]
+		buf = buf[46+namelen+xlen+fclen:]
+		if string(zname) != name {
+			continue
+		}
+		if meth != 0 {
+			return nil, errors.New("unsupported compression for " + name + " in " + zipfile)
+		}
+
+		// zip per-file header layout:
+		//	0	magic[4]
+		//	4	extvers[1]
+		//	5	extos[1]
+		//	6	flags[2]
+		//	8	meth[2]
+		//	10	modtime[2]
+		//	12	moddate[2]
+		//	14	crc[4]
+		//	18	csize[4]
+		//	22	uncsize[4]
+		//	26	namelen[2]
+		//	28	xlen[2]
+		//	30	name[namelen]
+		//	30+namelen+xlen - file data
+		//
+		buf = make([]byte, zheadersize+namelen)
+		if err := preadn(fd, buf, off); err != nil ||
+			get4(buf) != zheader ||
+			get2(buf[8:]) != meth ||
+			get2(buf[26:]) != namelen ||
+			string(buf[30:30+namelen]) != name {
+			return nil, errors.New("corrupt zip file " + zipfile)
+		}
+		xlen = get2(buf[28:])
+
+		buf = make([]byte, size)
+		if err := preadn(fd, buf, off+30+namelen+xlen); err != nil {
+			return nil, errors.New("corrupt zip file " + zipfile)
+		}
+
+		return buf, nil
+	}
+
+	return nil, syscall.ENOENT
+}
+
+// loadTzinfoFromTzdata returns the time zone information of the time zone
+// with the given name, from a tzdata database file as they are typically
+// found on android.
+var loadTzinfoFromTzdata func(file, name string) ([]byte, error)
+
+// loadTzinfo returns the time zone information of the time zone
+// with the given name, from a given source. A source may be a
+// timezone database directory, tzdata database file or an uncompressed
+// zip file, containing the contents of such a directory.
+func loadTzinfo(name string, source string) ([]byte, error) {
+	if len(source) >= 6 && source[len(source)-6:] == "tzdata" {
+		return loadTzinfoFromTzdata(source, name)
+	}
+	return loadTzinfoFromDirOrZip(source, name)
+}
+
+// loadLocation returns the Location with the given name from one of
+// the specified sources. See loadTzinfo for a list of supported sources.
+// The first timezone data matching the given name that is successfully loaded
+// and parsed is returned as a Location.
+func loadLocation(name string, sources []string) (z *Location, firstErr error) {
+	for _, source := range sources {
+		zoneData, err := loadTzinfo(name, source)
+		if err == nil {
+			if z, err = LoadLocationFromTZData(name, zoneData); err == nil {
+				return z, nil
+			}
+		}
+		if firstErr == nil && err != syscall.ENOENT {
+			firstErr = err
+		}
+	}
+	if loadFromEmbeddedTZData != nil {
+		zoneData, err := loadFromEmbeddedTZData(name)
+		if err == nil {
+			if z, err = LoadLocationFromTZData(name, []byte(zoneData)); err == nil {
+				return z, nil
+			}
+		}
+		if firstErr == nil && err != syscall.ENOENT {
+			firstErr = err
+		}
+	}
+	if source, ok := gorootZoneSource(runtime.GOROOT()); ok {
+		zoneData, err := loadTzinfo(name, source)
+		if err == nil {
+			if z, err = LoadLocationFromTZData(name, zoneData); err == nil {
+				return z, nil
+			}
+		}
+		if firstErr == nil && err != syscall.ENOENT {
+			firstErr = err
+		}
+	}
+	if firstErr != nil {
+		return nil, firstErr
+	}
+	return nil, errors.New("unknown time zone " + name)
+}
+
+// readFile reads and returns the content of the named file.
+// It is a trivial implementation of os.ReadFile, reimplemented
+// here to avoid depending on io/ioutil or os.
+// It returns an error if name exceeds maxFileSize bytes.
+func readFile(name string) ([]byte, error) {
+	f, err := open(name)
+	if err != nil {
+		return nil, err
+	}
+	defer closefd(f)
+	var (
+		buf [4096]byte
+		ret []byte
+		n   int
+	)
+	for {
+		n, err = read(f, buf[:])
+		if n > 0 {
+			ret = append(ret, buf[:n]...)
+		}
+		if n == 0 || err != nil {
+			break
+		}
+		if len(ret) > maxFileSize {
+			return nil, fileSizeError(name)
+		}
+	}
+	return ret, err
+}
+
+func gorootZoneSource(goroot string) (string, bool) {
+	if goroot == "" {
+		return "", false
+	}
+	return goroot + "/lib/time/zoneinfo.zip", true
+}
+
+func nowSec() (sec int64) {
+	var tv time.Timespec
+	time.ClockGettime(0, &tv)
+	return int64(tv.Sec)
+}

compiler/internal/lib/time/zoneinfo_unix.go

@@ -0,0 +1,69 @@
+// Copyright 2009 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.
+
+//go:build unix && !ios && !android
+
+// Parse "zoneinfo" time zone file.
+// This is a fairly standard file format used on OS X, Linux, BSD, Sun, and others.
+// See tzfile(5), https://en.wikipedia.org/wiki/Zoneinfo,
+// and ftp://munnari.oz.au/pub/oldtz/
+
+package time
+
+import (
+	"syscall"
+)
+
+// Many systems use /usr/share/zoneinfo, Solaris 2 has
+// /usr/share/lib/zoneinfo, IRIX 6 has /usr/lib/locale/TZ,
+// NixOS has /etc/zoneinfo.
+var platformZoneSources = []string{
+	"/usr/share/zoneinfo/",
+	"/usr/share/lib/zoneinfo/",
+	"/usr/lib/locale/TZ/",
+	"/etc/zoneinfo",
+}
+
+func initLocal() {
+	// consult $TZ to find the time zone to use.
+	// no $TZ means use the system default /etc/localtime.
+	// $TZ="" means use UTC.
+	// $TZ="foo" or $TZ=":foo" if foo is an absolute path, then the file pointed
+	// by foo will be used to initialize timezone; otherwise, file
+	// /usr/share/zoneinfo/foo will be used.
+
+	tz, ok := syscall.Getenv("TZ")
+	switch {
+	case !ok:
+		z, err := loadLocation("localtime", []string{"/etc"})
+		if err == nil {
+			localLoc = *z
+			localLoc.name = "Local"
+			return
+		}
+	case tz != "":
+		if tz[0] == ':' {
+			tz = tz[1:]
+		}
+		if tz != "" && tz[0] == '/' {
+			if z, err := loadLocation(tz, []string{""}); err == nil {
+				localLoc = *z
+				if tz == "/etc/localtime" {
+					localLoc.name = "Local"
+				} else {
+					localLoc.name = tz
+				}
+				return
+			}
+		} else if tz != "" && tz != "UTC" {
+			if z, err := loadLocation(tz, platformZoneSources); err == nil {
+				localLoc = *z
+				return
+			}
+		}
+	}
+
+	// Fall back to UTC.
+	localLoc.name = "UTC"
+}