use new aligned atomic types everywhere

See 69448b13a1 / #1969; the compiler can now ensure that a uint64
intended for atomic access is always aligned to a 64-bit boundary.
Convert atomic operations on uint32s and pointers as well.

irc/client.go

 	sasl       saslStatus
 	passStatus serverPassStatus
 
-	batchCounter uint32
+	batchCounter atomic.Uint32
 
 	quitMessage string
 
 // or nesting) on an individual session connection need to be unique.
 // this allows ~4 billion such batches which should be fine.
 func (session *Session) generateBatchID() string {
-	id := atomic.AddUint32(&session.batchCounter, 1)
+	id := session.batchCounter.Add(1)
 	return strconv.FormatInt(int64(id), 32)
 }
 

irc/getters.go

 import (
 	"fmt"
 	"net"
-	"sync/atomic"
 	"time"
 
 	"github.com/ergochat/ergo/irc/caps"
 }
 
 func (server *Server) Defcon() uint32 {
-	return atomic.LoadUint32(&server.defcon)
+	return server.defcon.Load()
 }
 
 func (server *Server) SetDefcon(defcon uint32) {
-	atomic.StoreUint32(&server.defcon, defcon)
+	server.defcon.Store(defcon)
 }
 
 func (client *Client) Sessions() (sessions []*Session) {

irc/logger/logger.go

 	loggers         []singleLogger
 	stdoutWriteLock sync.Mutex // use one lock for both stdout and stderr
 	fileWriteLock   sync.Mutex
-	loggingRawIO    uint32
+	loggingRawIO    atomic.Uint32
 }
 
 // LoggingConfig represents the configuration of a single logger.
 	}
 
 	logger.loggers = nil
-	atomic.StoreUint32(&logger.loggingRawIO, 0)
+	logger.loggingRawIO.Store(0)
 
 	// for safety, this deep-copies all mutable data in `config`
 	// XXX let's keep it that way
 		ioEnabled := typeMap["userinput"] || typeMap["useroutput"] || (typeMap["*"] && !(excludedTypeMap["userinput"] && excludedTypeMap["useroutput"]))
 		// raw I/O is only logged at level debug;
 		if ioEnabled && logConfig.Level == LogDebug {
-			atomic.StoreUint32(&logger.loggingRawIO, 1)
+			logger.loggingRawIO.Store(1)
 		}
 		if sLogger.MethodFile.Enabled {
 			file, err := os.OpenFile(sLogger.MethodFile.Filename, os.O_CREATE|os.O_APPEND|os.O_WRONLY, 0666)
 
 // IsLoggingRawIO returns true if raw user input and output is being logged.
 func (logger *Manager) IsLoggingRawIO() bool {
-	return atomic.LoadUint32(&logger.loggingRawIO) == 1
+	return logger.loggingRawIO.Load() == 1
 }
 
 // Log logs the given message with the given details.

irc/mysql/history.go

 type e struct{}
 
 type MySQL struct {
-	timeout              *int64
-	trackAccountMessages uint32
-	db                   *sql.DB
-	logger               *logger.Manager
+	db     *sql.DB
+	logger *logger.Manager
 
 	insertHistory        *sql.Stmt
 	insertSequence       *sql.Stmt
 	config     Config
 
 	wakeForgetter chan e
+
+	timeout              atomic.Uint64
+	trackAccountMessages atomic.Uint32
 }
 
 func (mysql *MySQL) Initialize(logger *logger.Manager, config Config) {
-	mysql.timeout = new(int64)
 	mysql.logger = logger
 	mysql.wakeForgetter = make(chan e, 1)
 	mysql.SetConfig(config)
 }
 
 func (mysql *MySQL) SetConfig(config Config) {
-	atomic.StoreInt64(mysql.timeout, int64(config.Timeout))
+	mysql.timeout.Store(uint64(config.Timeout))
 	var trackAccountMessages uint32
 	if config.TrackAccountMessages {
 		trackAccountMessages = 1
 	}
-	atomic.StoreUint32(&mysql.trackAccountMessages, trackAccountMessages)
+	mysql.trackAccountMessages.Store(trackAccountMessages)
 	mysql.stateMutex.Lock()
 	mysql.config = config
 	mysql.stateMutex.Unlock()
 }
 
 func (mysql *MySQL) getTimeout() time.Duration {
-	return time.Duration(atomic.LoadInt64(mysql.timeout))
+	return time.Duration(mysql.timeout.Load())
 }
 
 func (mysql *MySQL) isTrackingAccountMessages() bool {
-	return atomic.LoadUint32(&mysql.trackAccountMessages) != 0
+	return mysql.trackAccountMessages.Load() != 0
 }
 
 func (mysql *MySQL) logError(context string, err error) (quit bool) {

irc/server.go

 	stats             Stats
 	semaphores        ServerSemaphores
 	flock             flock.Flocker
-	defcon            uint32
+	defcon            atomic.Uint32
 }
 
 // NewServer returns a new Oragono server.
 		logger:       logger,
 		rehashSignal: make(chan os.Signal, 1),
 		exitSignals:  make(chan os.Signal, len(utils.ServerExitSignals)),
-		defcon:       5,
 	}
+	server.defcon.Store(5)
 
 	server.accepts.Initialize()
 	server.clients.Initialize()

irc/usermaskset.go

 	"sync"
 	"sync/atomic"
 	"time"
-	"unsafe"
 
 	"github.com/ergochat/ergo/irc/utils"
 )
 	sync.RWMutex
 	serialCacheUpdateMutex sync.Mutex
 	masks                  map[string]MaskInfo
-	regexp                 unsafe.Pointer
-	muteRegexp             unsafe.Pointer
+	regexp                 atomic.Pointer[regexp.Regexp]
+	muteRegexp             atomic.Pointer[regexp.Regexp]
 }
 
 func NewUserMaskSet() *UserMaskSet {
 
 // Match matches the given n!u@h against the standard (non-ext) bans.
 func (set *UserMaskSet) Match(userhost string) bool {
-	regexp := (*regexp.Regexp)(atomic.LoadPointer(&set.regexp))
+	regexp := set.regexp.Load()
 
 	if regexp == nil {
 		return false
 }
 
 func (set *UserMaskSet) MuteRegexp() *regexp.Regexp {
-	return (*regexp.Regexp)(atomic.LoadPointer(&set.muteRegexp))
+	return set.muteRegexp.Load()
 }
 
 func (set *UserMaskSet) Length() int {
 	re := compileMasks(maskExprs)
 	muteRe := compileMasks(muteExprs)
 
-	atomic.StorePointer(&set.regexp, unsafe.Pointer(re))
-	atomic.StorePointer(&set.muteRegexp, unsafe.Pointer(muteRe))
+	set.regexp.Store(re)
+	set.muteRegexp.Store(muteRe)
 }