Attachment 230255 Details for Bug 260555 – Poudriere build fail log

Poudriere build fail log

haproxy-2.4.9.log (text/plain), 157.49 KB, created by Victor Sudakov on 2021-12-20 02:13:45 UTC

(hide)

Description:

Filename:

MIME Type:

Creator: Victor Sudakov

Created: 2021-12-20 02:13:45 UTC

Size: 157.49 KB

patch

obsolete

>=>> Building net/haproxy
>build started at Mon Dec 20 01:10:20 +07 2021
>port directory: /usr/ports/net/haproxy
>package name: haproxy-2.4.9
>building for: FreeBSD 123i386-default-job-01 12.3-RELEASE FreeBSD 12.3-RELEASE i386
>maintained by: demon@FreeBSD.org
>Makefile ident: 
>Poudriere version: 3.3.7_1
>Host OSVERSION: 1203000
>Jail OSVERSION: 1203000
>Job Id: 01
>
>---Begin Environment---
>SHELL=/bin/csh
>UNAME_p=i386
>UNAME_m=i386
>OSVERSION=1203000
>UNAME_v=FreeBSD 12.3-RELEASE
>UNAME_r=12.3-RELEASE
>BLOCKSIZE=K
>MAIL=/var/mail/root
>STATUS=1
>HOME=/root
>PATH=/sbin:/bin:/usr/sbin:/usr/bin:/usr/local/sbin:/usr/local/bin:/root/bin
>LOCALBASE=/usr/local
>USER=root
>LIBEXECPREFIX=/usr/local/libexec/poudriere
>POUDRIERE_VERSION=3.3.7_1
>MASTERMNT=/poudriere/data/.m/123i386-default/ref
>POUDRIERE_BUILD_TYPE=bulk
>PACKAGE_BUILDING=yes
>SAVED_TERM=screen
>PWD=/poudriere/data/.m/123i386-default/ref/.p/pool
>P_PORTS_FEATURES=FLAVORS SELECTED_OPTIONS
>MASTERNAME=123i386-default
>SCRIPTPREFIX=/usr/local/share/poudriere
>OLDPWD=/poudriere/data/.m/123i386-default/ref/.p
>SCRIPTPATH=/usr/local/share/poudriere/bulk.sh
>POUDRIEREPATH=/usr/local/bin/poudriere
>---End Environment---
>
>---Begin Poudriere Port Flags/Env---
>PORT_FLAGS=
>PKGENV=
>FLAVOR=default
>DEPENDS_ARGS=
>MAKE_ARGS= FLAVOR=default
>---End Poudriere Port Flags/Env---
>
>---Begin OPTIONS List---
>===> The following configuration options are available for haproxy-2.4.9:
>     DEVICEATLAS=off: DeviceAtlas Device Detection support
>     DOCS=on: Build and/or install documentation
>     EXAMPLES=on: Build and/or install examples
>     LUA=off: Lua scripting language support
>     OPENSSL=on: SSL/TLS support via OpenSSL
>     PROMEX=off: Enable Prometheus exporter
>====> Use Perl Compatible Regular Expressions: you can only select none or one of them
>     DPCRE=off: Link dynamically
>     SPCRE=on: Link statically
>===> Use 'make config' to modify these settings
>---End OPTIONS List---
>
>--MAINTAINER--
>demon@FreeBSD.org
>--End MAINTAINER--
>
>--CONFIGURE_ARGS--
>
>--End CONFIGURE_ARGS--
>
>--CONFIGURE_ENV--
>MAKE=gmake XDG_DATA_HOME=/wrkdirs/usr/ports/net/haproxy/work-default  XDG_CONFIG_HOME=/wrkdirs/usr/ports/net/haproxy/work-default  XDG_CACHE_HOME=/wrkdirs/usr/ports/net/haproxy/work-default/.cache  HOME=/wrkdirs/usr/ports/net/haproxy/work-default TMPDIR="/tmp" PATH=/wrkdirs/usr/ports/net/haproxy/work-default/.bin:/sbin:/bin:/usr/sbin:/usr/bin:/usr/local/sbin:/usr/local/bin:/root/bin SHELL=/bin/sh CONFIG_SHELL=/bin/sh
>--End CONFIGURE_ENV--
>
>--MAKE_ENV--
>OPENSSLBASE=/usr OPENSSLDIR=/etc/ssl OPENSSLINC=/usr/include OPENSSLLIB=/usr/lib XDG_DATA_HOME=/wrkdirs/usr/ports/net/haproxy/work-default  XDG_CONFIG_HOME=/wrkdirs/usr/ports/net/haproxy/work-default  XDG_CACHE_HOME=/wrkdirs/usr/ports/net/haproxy/work-default/.cache  HOME=/wrkdirs/usr/ports/net/haproxy/work-default TMPDIR="/tmp" PATH=/wrkdirs/usr/ports/net/haproxy/work-default/.bin:/sbin:/bin:/usr/sbin:/usr/bin:/usr/local/sbin:/usr/local/bin:/root/bin NO_PIE=yes MK_DEBUG_FILES=no MK_KERNEL_SYMBOLS=no SHELL=/bin/sh NO_LINT=YES PREFIX=/usr/local  LOCALBASE=/usr/local  CC="cc" CFLAGS="-O2 -pipe  -fstack-protector-strong -fno-strict-aliasing "  CPP="cpp" CPPFLAGS=""  LDFLAGS="  -fstack-protector-strong " LIBS=""  CXX="c++" CXXFLAGS="-O2 -pipe -fstack-protector-strong -fno-strict-aliasing  "  MANPREFIX="/usr/local" BSD_INSTALL_PROGRAM="install  -s -m 555"  BSD_INSTALL_LIB="install  -s -m 0644"  BSD_INSTALL_SCRIPT="install  -m 555"  BSD_INSTALL_DATA="install  -m 0644"  BSD_INSTALL_MAN="install  -m 444"
>--End MAKE_ENV--
>
>--PLIST_SUB--
>PORTDOCS="" PORTEXAMPLES="" OSREL=12.3 PREFIX=%D LOCALBASE=/usr/local  RESETPREFIX=/usr/local LIB32DIR=lib DOCSDIR="share/doc/haproxy"  EXAMPLESDIR="share/examples/haproxy"  DATADIR="share/haproxy"  WWWDIR="www/haproxy"  ETCDIR="etc/haproxy"
>--End PLIST_SUB--
>
>--SUB_LIST--
> PREFIX=/usr/local LOCALBASE=/usr/local  DATADIR=/usr/local/share/haproxy DOCSDIR=/usr/local/share/doc/haproxy EXAMPLESDIR=/usr/local/share/examples/haproxy  WWWDIR=/usr/local/www/haproxy ETCDIR=/usr/local/etc/haproxy
>--End SUB_LIST--
>
>---Begin make.conf---
>USE_PACKAGE_DEPENDS=yes
>BATCH=yes
>WRKDIRPREFIX=/wrkdirs
>PORTSDIR=/usr/ports
>PACKAGES=/packages
>DISTDIR=/distfiles
>FORCE_PACKAGE=yes
>PACKAGE_BUILDING=yes
>PACKAGE_BUILDING_FLAVORS=yes
>MACHINE=i386
>MACHINE_ARCH=i386
>ARCH=${MACHINE_ARCH}
>#### /usr/local/etc/poudriere.d/make.conf ####
># by VAS
>OPTIONS_UNSET= NLS CUPS BDB X11 LLDB WAYLAND
>OPTIONS_SET= DOCS MANPAGES IPV6 IDN
>DEFAULT_VERSIONS+=pgsql=12 php=7.3
>DISABLE_LICENSES=yes
>ALLOW_UNSUPPORTED_SYSTEM=yes
>#### Misc Poudriere ####
>.include "/etc/make.conf.ports_env"
>GID=0
>UID=0
>DISABLE_MAKE_JOBS=poudriere
>---End make.conf---
>--Resource limits--
>cpu time               (seconds, -t)  unlimited
>file size           (512-blocks, -f)  unlimited
>data seg size           (kbytes, -d)  524288
>stack size              (kbytes, -s)  65536
>core file size      (512-blocks, -c)  unlimited
>max memory size         (kbytes, -m)  unlimited
>locked memory           (kbytes, -l)  unlimited
>max user processes              (-u)  10342
>open files                      (-n)  1024
>virtual mem size        (kbytes, -v)  unlimited
>swap limit              (kbytes, -w)  unlimited
>socket buffer size       (bytes, -b)  unlimited
>pseudo-terminals                (-p)  unlimited
>kqueues                         (-k)  unlimited
>umtx shared locks               (-o)  unlimited
>--End resource limits--
>=======================<phase: check-sanity   >============================
>===========================================================================
>=======================<phase: pkg-depends    >============================
>===>   haproxy-2.4.9 depends on file: /usr/local/sbin/pkg - not found
>===>   Installing existing package /packages/All/pkg-1.17.5.pkg
>[123i386-default-job-01] Installing pkg-1.17.5...
>[123i386-default-job-01] Extracting pkg-1.17.5: .......... done
>===>   haproxy-2.4.9 depends on file: /usr/local/sbin/pkg - found
>===>   Returning to build of haproxy-2.4.9
>===========================================================================
>=======================<phase: fetch-depends  >============================
>===========================================================================
>=======================<phase: fetch          >============================
>===> Fetching all distfiles required by haproxy-2.4.9 for building
>===========================================================================
>=======================<phase: checksum       >============================
>===> Fetching all distfiles required by haproxy-2.4.9 for building
>=> SHA256 Checksum OK for haproxy-2.4.9.tar.gz.
>===========================================================================
>=======================<phase: extract-depends>============================
>===========================================================================
>=======================<phase: extract        >============================
>===> Fetching all distfiles required by haproxy-2.4.9 for building
>===>  Extracting for haproxy-2.4.9
>=> SHA256 Checksum OK for haproxy-2.4.9.tar.gz.
>===========================================================================
>=======================<phase: patch-depends  >============================
>===========================================================================
>=======================<phase: patch          >============================
>===>  Patching for haproxy-2.4.9
>===>  Applying FreeBSD patches for haproxy-2.4.9 from /usr/ports/net/haproxy/files
>===========================================================================
>=======================<phase: build-depends  >============================
>===>   haproxy-2.4.9 depends on package: gmake>=4.3 - not found
>===>   Installing existing package /packages/All/gmake-4.3_2.pkg
>[123i386-default-job-01] Installing gmake-4.3_2...
>[123i386-default-job-01] `-- Installing indexinfo-0.3.1...
>[123i386-default-job-01] `-- Extracting indexinfo-0.3.1: . done
>[123i386-default-job-01] Extracting gmake-4.3_2: ...... done
>===>   haproxy-2.4.9 depends on package: gmake>=4.3 - found
>===>   Returning to build of haproxy-2.4.9
>===========================================================================
>=======================<phase: lib-depends    >============================
>===>   haproxy-2.4.9 depends on shared library: libpcre.so - not found
>===>   Installing existing package /packages/All/pcre-8.45.pkg
>[123i386-default-job-01] Installing pcre-8.45...
>[123i386-default-job-01] Extracting pcre-8.45: .......... done
>===>   haproxy-2.4.9 depends on shared library: libpcre.so - found (/usr/local/lib/libpcre.so)
>===>   Returning to build of haproxy-2.4.9
>===========================================================================
>=======================<phase: configure      >============================
>===>  Configuring for haproxy-2.4.9
>===========================================================================
>=======================<phase: build          >============================
>===>  Building for haproxy-2.4.9
>gmake[1]: Entering directory '/wrkdirs/usr/ports/net/haproxy/work-default/haproxy-2.4.9'
>  CC      src/ev_poll.o
>  CC      src/ev_kqueue.o
>  CC      src/cpuset.o
>  CC      src/ssl_sample.o
>  CC      src/ssl_sock.o
>src/ssl_sock.c:5698:4: warning: large atomic operation may incur significant performance penalty [-Watomic-alignment]
>                        HA_ATOMIC_INC(&counters->sess);
>                        ^
>include/haproxy/atomic.h:317:43: note: expanded from macro 'HA_ATOMIC_INC'
>#define HA_ATOMIC_INC(val)           do { __atomic_add_fetch(val, 1, __ATOMIC_SEQ_CST); } while (0)
>                                          ^
>src/ssl_sock.c:5699:4: warning: large atomic operation may incur significant performance penalty [-Watomic-alignment]
>                        HA_ATOMIC_INC(&counters_px->sess);
>                        ^
>include/haproxy/atomic.h:317:43: note: expanded from macro 'HA_ATOMIC_INC'
>#define HA_ATOMIC_INC(val)           do { __atomic_add_fetch(val, 1, __ATOMIC_SEQ_CST); } while (0)
>                                          ^
>src/ssl_sock.c:5703:3: warning: large atomic operation may incur significant performance penalty [-Watomic-alignment]
>                HA_ATOMIC_INC(&counters->reused_sess);
>                ^
>include/haproxy/atomic.h:317:43: note: expanded from macro 'HA_ATOMIC_INC'
>#define HA_ATOMIC_INC(val)           do { __atomic_add_fetch(val, 1, __ATOMIC_SEQ_CST); } while (0)
>                                          ^
>src/ssl_sock.c:5704:3: warning: large atomic operation may incur significant performance penalty [-Watomic-alignment]
>                HA_ATOMIC_INC(&counters_px->reused_sess);
>                ^
>include/haproxy/atomic.h:317:43: note: expanded from macro 'HA_ATOMIC_INC'
>#define HA_ATOMIC_INC(val)           do { __atomic_add_fetch(val, 1, __ATOMIC_SEQ_CST); } while (0)
>                                          ^
>src/ssl_sock.c:5730:3: warning: large atomic operation may incur significant performance penalty [-Watomic-alignment]
>                HA_ATOMIC_INC(&counters->failed_handshake);
>                ^
>include/haproxy/atomic.h:317:43: note: expanded from macro 'HA_ATOMIC_INC'
>#define HA_ATOMIC_INC(val)           do { __atomic_add_fetch(val, 1, __ATOMIC_SEQ_CST); } while (0)
>                                          ^
>src/ssl_sock.c:5731:3: warning: large atomic operation may incur significant performance penalty [-Watomic-alignment]
>                HA_ATOMIC_INC(&counters_px->failed_handshake);
>                ^
>include/haproxy/atomic.h:317:43: note: expanded from macro 'HA_ATOMIC_INC'
>#define HA_ATOMIC_INC(val)           do { __atomic_add_fetch(val, 1, __ATOMIC_SEQ_CST); } while (0)
>                                          ^
>6 warnings generated.
>  CC      src/ssl_crtlist.o
>  CC      src/ssl_ckch.o
>  CC      src/ssl_utils.o
>  CC      src/cfgparse-ssl.o
>  CC      src/mux_h2.o
>src/mux_h2.c:3228:5: warning: large atomic operation may incur significant performance penalty [-Watomic-alignment]
>                                HA_ATOMIC_INC(&h2c->px_counters->conn_proto_err);
>                                ^
>include/haproxy/atomic.h:317:43: note: expanded from macro 'HA_ATOMIC_INC'
>#define HA_ATOMIC_INC(val)           do { __atomic_add_fetch(val, 1, __ATOMIC_SEQ_CST); } while (0)
>                                          ^
>src/mux_h2.c:3247:4: warning: large atomic operation may incur significant performance penalty [-Watomic-alignment]
>                        HA_ATOMIC_INC(&h2c->px_counters->settings_rcvd);
>                        ^
>include/haproxy/atomic.h:317:43: note: expanded from macro 'HA_ATOMIC_INC'
>#define HA_ATOMIC_INC(val)           do { __atomic_add_fetch(val, 1, __ATOMIC_SEQ_CST); } while (0)
>                                          ^
>src/mux_h2.c:3283:5: warning: large atomic operation may incur significant performance penalty [-Watomic-alignment]
>                                HA_ATOMIC_INC(&h2c->px_counters->conn_proto_err);
>                                ^
>include/haproxy/atomic.h:317:43: note: expanded from macro 'HA_ATOMIC_INC'
>#define HA_ATOMIC_INC(val)           do { __atomic_add_fetch(val, 1, __ATOMIC_SEQ_CST); } while (0)
>                                          ^
>src/mux_h2.c:3301:6: warning: large atomic operation may incur significant performance penalty [-Watomic-alignment]
>                                        HA_ATOMIC_INC(&h2c->px_counters->conn_proto_err);
>                                        ^
>include/haproxy/atomic.h:317:43: note: expanded from macro 'HA_ATOMIC_INC'
>#define HA_ATOMIC_INC(val)           do { __atomic_add_fetch(val, 1, __ATOMIC_SEQ_CST); } while (0)
>                                          ^
>src/mux_h2.c:3321:6: warning: large atomic operation may incur significant performance penalty [-Watomic-alignment]
>                                        HA_ATOMIC_INC(&h2c->px_counters->conn_proto_err);
>                                        ^
>include/haproxy/atomic.h:317:43: note: expanded from macro 'HA_ATOMIC_INC'
>#define HA_ATOMIC_INC(val)           do { __atomic_add_fetch(val, 1, __ATOMIC_SEQ_CST); } while (0)
>                                          ^
>src/mux_h2.c:3349:5: warning: large atomic operation may incur significant performance penalty [-Watomic-alignment]
>                                HA_ATOMIC_INC(&h2c->px_counters->conn_proto_err);
>                                ^
>include/haproxy/atomic.h:317:43: note: expanded from macro 'HA_ATOMIC_INC'
>#define HA_ATOMIC_INC(val)           do { __atomic_add_fetch(val, 1, __ATOMIC_SEQ_CST); } while (0)
>                                          ^
>src/mux_h2.c:3388:4: warning: large atomic operation may incur significant performance penalty [-Watomic-alignment]
>                        HA_ATOMIC_INC(&h2c->px_counters->settings_rcvd);
>                        ^
>include/haproxy/atomic.h:317:43: note: expanded from macro 'HA_ATOMIC_INC'
>#define HA_ATOMIC_INC(val)           do { __atomic_add_fetch(val, 1, __ATOMIC_SEQ_CST); } while (0)
>                                          ^
>src/mux_h2.c:3425:4: warning: large atomic operation may incur significant performance penalty [-Watomic-alignment]
>                        HA_ATOMIC_INC(&h2c->px_counters->conn_proto_err);
>                        ^
>include/haproxy/atomic.h:317:43: note: expanded from macro 'HA_ATOMIC_INC'
>#define HA_ATOMIC_INC(val)           do { __atomic_add_fetch(val, 1, __ATOMIC_SEQ_CST); } while (0)
>                                          ^
>src/mux_h2.c:3440:4: warning: large atomic operation may incur significant performance penalty [-Watomic-alignment]
>                        HA_ATOMIC_INC(&h2c->px_counters->headers_rcvd);
>                        ^
>include/haproxy/atomic.h:317:43: note: expanded from macro 'HA_ATOMIC_INC'
>#define HA_ATOMIC_INC(val)           do { __atomic_add_fetch(val, 1, __ATOMIC_SEQ_CST); } while (0)
>                                          ^
>src/mux_h2.c:3448:4: warning: large atomic operation may incur significant performance penalty [-Watomic-alignment]
>                        HA_ATOMIC_INC(&h2c->px_counters->data_rcvd);
>                        ^
>include/haproxy/atomic.h:317:43: note: expanded from macro 'HA_ATOMIC_INC'
>#define HA_ATOMIC_INC(val)           do { __atomic_add_fetch(val, 1, __ATOMIC_SEQ_CST); } while (0)
>                                          ^
>src/mux_h2.c:3468:4: warning: large atomic operation may incur significant performance penalty [-Watomic-alignment]
>                        HA_ATOMIC_INC(&h2c->px_counters->rst_stream_rcvd);
>                        ^
>include/haproxy/atomic.h:317:43: note: expanded from macro 'HA_ATOMIC_INC'
>#define HA_ATOMIC_INC(val)           do { __atomic_add_fetch(val, 1, __ATOMIC_SEQ_CST); } while (0)
>                                          ^
>src/mux_h2.c:3476:4: warning: large atomic operation may incur significant performance penalty [-Watomic-alignment]
>                        HA_ATOMIC_INC(&h2c->px_counters->goaway_rcvd);
>                        ^
>include/haproxy/atomic.h:317:43: note: expanded from macro 'HA_ATOMIC_INC'
>#define HA_ATOMIC_INC(val)           do { __atomic_add_fetch(val, 1, __ATOMIC_SEQ_CST); } while (0)
>                                          ^
>src/mux_h2.c:1732:5: warning: large atomic operation may incur significant performance penalty [-Watomic-alignment]
>                                HA_ATOMIC_INC(&h2c->px_counters->conn_proto_err);
>                                ^
>include/haproxy/atomic.h:317:43: note: expanded from macro 'HA_ATOMIC_INC'
>#define HA_ATOMIC_INC(val)           do { __atomic_add_fetch(val, 1, __ATOMIC_SEQ_CST); } while (0)
>                                          ^
>src/mux_h2.c:3051:3: warning: large atomic operation may incur significant performance penalty [-Watomic-alignment]
>                HA_ATOMIC_INC(&h2c->px_counters->conn_proto_err);
>                ^
>include/haproxy/atomic.h:317:43: note: expanded from macro 'HA_ATOMIC_INC'
>#define HA_ATOMIC_INC(val)           do { __atomic_add_fetch(val, 1, __ATOMIC_SEQ_CST); } while (0)
>                                          ^
>src/mux_h2.c:3060:3: warning: large atomic operation may incur significant performance penalty [-Watomic-alignment]
>                HA_ATOMIC_INC(&h2c->px_counters->conn_proto_err);
>                ^
>include/haproxy/atomic.h:317:43: note: expanded from macro 'HA_ATOMIC_INC'
>#define HA_ATOMIC_INC(val)           do { __atomic_add_fetch(val, 1, __ATOMIC_SEQ_CST); } while (0)
>                                          ^
>src/mux_h2.c:3075:4: warning: large atomic operation may incur significant performance penalty [-Watomic-alignment]
>                        HA_ATOMIC_INC(&h2c->px_counters->conn_proto_err);
>                        ^
>include/haproxy/atomic.h:317:43: note: expanded from macro 'HA_ATOMIC_INC'
>#define HA_ATOMIC_INC(val)           do { __atomic_add_fetch(val, 1, __ATOMIC_SEQ_CST); } while (0)
>                                          ^
>src/mux_h2.c:2227:5: warning: large atomic operation may incur significant performance penalty [-Watomic-alignment]
>                                HA_ATOMIC_INC(&h2c->px_counters->conn_proto_err);
>                                ^
>include/haproxy/atomic.h:317:43: note: expanded from macro 'HA_ATOMIC_INC'
>#define HA_ATOMIC_INC(val)           do { __atomic_add_fetch(val, 1, __ATOMIC_SEQ_CST); } while (0)
>                                          ^
>src/mux_h2.c:2236:5: warning: large atomic operation may incur significant performance penalty [-Watomic-alignment]
>                                HA_ATOMIC_INC(&h2c->px_counters->conn_proto_err);
>                                ^
>include/haproxy/atomic.h:317:43: note: expanded from macro 'HA_ATOMIC_INC'
>#define HA_ATOMIC_INC(val)           do { __atomic_add_fetch(val, 1, __ATOMIC_SEQ_CST); } while (0)
>                                          ^
>src/mux_h2.c:2513:4: warning: large atomic operation may incur significant performance penalty [-Watomic-alignment]
>                        HA_ATOMIC_INC(&h2c->px_counters->strm_proto_err);
>                        ^
>include/haproxy/atomic.h:317:43: note: expanded from macro 'HA_ATOMIC_INC'
>#define HA_ATOMIC_INC(val)           do { __atomic_add_fetch(val, 1, __ATOMIC_SEQ_CST); } while (0)
>                                          ^
>src/mux_h2.c:2520:4: warning: large atomic operation may incur significant performance penalty [-Watomic-alignment]
>                        HA_ATOMIC_INC(&h2c->px_counters->strm_proto_err);
>                        ^
>include/haproxy/atomic.h:317:43: note: expanded from macro 'HA_ATOMIC_INC'
>#define HA_ATOMIC_INC(val)           do { __atomic_add_fetch(val, 1, __ATOMIC_SEQ_CST); } while (0)
>                                          ^
>src/mux_h2.c:2538:4: warning: large atomic operation may incur significant performance penalty [-Watomic-alignment]
>                        HA_ATOMIC_INC(&h2c->px_counters->conn_proto_err);
>                        ^
>include/haproxy/atomic.h:317:43: note: expanded from macro 'HA_ATOMIC_INC'
>#define HA_ATOMIC_INC(val)           do { __atomic_add_fetch(val, 1, __ATOMIC_SEQ_CST); } while (0)
>                                          ^
>src/mux_h2.c:2850:3: warning: large atomic operation may incur significant performance penalty [-Watomic-alignment]
>                HA_ATOMIC_INC(&h2c->px_counters->strm_proto_err);
>                ^
>include/haproxy/atomic.h:317:43: note: expanded from macro 'HA_ATOMIC_INC'
>#define HA_ATOMIC_INC(val)           do { __atomic_add_fetch(val, 1, __ATOMIC_SEQ_CST); } while (0)
>                                          ^
>src/mux_h2.c:2866:3: warning: large atomic operation may incur significant performance penalty [-Watomic-alignment]
>                HA_ATOMIC_INC(&h2c->px_counters->strm_proto_err);
>                ^
>include/haproxy/atomic.h:317:43: note: expanded from macro 'HA_ATOMIC_INC'
>#define HA_ATOMIC_INC(val)           do { __atomic_add_fetch(val, 1, __ATOMIC_SEQ_CST); } while (0)
>                                          ^
>src/mux_h2.c:4692:4: warning: large atomic operation may incur significant performance penalty [-Watomic-alignment]
>                        HA_ATOMIC_INC(&h2c->px_counters->conn_proto_err);
>                        ^
>include/haproxy/atomic.h:317:43: note: expanded from macro 'HA_ATOMIC_INC'
>#define HA_ATOMIC_INC(val)           do { __atomic_add_fetch(val, 1, __ATOMIC_SEQ_CST); } while (0)
>                                          ^
>src/mux_h2.c:4700:4: warning: large atomic operation may incur significant performance penalty [-Watomic-alignment]
>                        HA_ATOMIC_INC(&h2c->px_counters->conn_proto_err);
>                        ^
>include/haproxy/atomic.h:317:43: note: expanded from macro 'HA_ATOMIC_INC'
>#define HA_ATOMIC_INC(val)           do { __atomic_add_fetch(val, 1, __ATOMIC_SEQ_CST); } while (0)
>                                          ^
>src/mux_h2.c:4753:4: warning: large atomic operation may incur significant performance penalty [-Watomic-alignment]
>                        HA_ATOMIC_INC(&h2c->px_counters->conn_proto_err);
>                        ^
>include/haproxy/atomic.h:317:43: note: expanded from macro 'HA_ATOMIC_INC'
>#define HA_ATOMIC_INC(val)           do { __atomic_add_fetch(val, 1, __ATOMIC_SEQ_CST); } while (0)
>                                          ^
>src/mux_h2.c:4896:3: warning: large atomic operation may incur significant performance penalty [-Watomic-alignment]
>                HA_ATOMIC_INC(&h2c->px_counters->conn_proto_err);
>                ^
>include/haproxy/atomic.h:317:43: note: expanded from macro 'HA_ATOMIC_INC'
>#define HA_ATOMIC_INC(val)           do { __atomic_add_fetch(val, 1, __ATOMIC_SEQ_CST); } while (0)
>                                          ^
>src/mux_h2.c:1408:3: warning: large atomic operation may incur significant performance penalty [-Watomic-alignment]
>                HA_ATOMIC_DEC(&h2s->h2c->px_counters->open_streams);
>                ^
>include/haproxy/atomic.h:318:43: note: expanded from macro 'HA_ATOMIC_DEC'
>#define HA_ATOMIC_DEC(val)           do { __atomic_sub_fetch(val, 1, __ATOMIC_SEQ_CST); } while (0)
>                                          ^
>src/mux_h2.c:2718:3: warning: large atomic operation may incur significant performance penalty [-Watomic-alignment]
>                HA_ATOMIC_INC(&h2c->px_counters->conn_proto_err);
>                ^
>include/haproxy/atomic.h:317:43: note: expanded from macro 'HA_ATOMIC_INC'
>#define HA_ATOMIC_INC(val)           do { __atomic_add_fetch(val, 1, __ATOMIC_SEQ_CST); } while (0)
>                                          ^
>src/mux_h2.c:1495:2: warning: large atomic operation may incur significant performance penalty [-Watomic-alignment]
>        HA_ATOMIC_INC(&h2c->px_counters->open_streams);
>        ^
>include/haproxy/atomic.h:317:43: note: expanded from macro 'HA_ATOMIC_INC'
>#define HA_ATOMIC_INC(val)           do { __atomic_add_fetch(val, 1, __ATOMIC_SEQ_CST); } while (0)
>                                          ^
>src/mux_h2.c:1496:2: warning: large atomic operation may incur significant performance penalty [-Watomic-alignment]
>        HA_ATOMIC_INC(&h2c->px_counters->total_streams);
>        ^
>include/haproxy/atomic.h:317:43: note: expanded from macro 'HA_ATOMIC_INC'
>#define HA_ATOMIC_INC(val)           do { __atomic_add_fetch(val, 1, __ATOMIC_SEQ_CST); } while (0)
>                                          ^
>src/mux_h2.c:2947:3: warning: large atomic operation may incur significant performance penalty [-Watomic-alignment]
>                HA_ATOMIC_INC(&h2c->px_counters->strm_proto_err);
>                ^
>include/haproxy/atomic.h:317:43: note: expanded from macro 'HA_ATOMIC_INC'
>#define HA_ATOMIC_INC(val)           do { __atomic_add_fetch(val, 1, __ATOMIC_SEQ_CST); } while (0)
>                                          ^
>src/mux_h2.c:3005:4: warning: large atomic operation may incur significant performance penalty [-Watomic-alignment]
>                        HA_ATOMIC_INC(&h2c->px_counters->strm_proto_err);
>                        ^
>include/haproxy/atomic.h:317:43: note: expanded from macro 'HA_ATOMIC_INC'
>#define HA_ATOMIC_INC(val)           do { __atomic_add_fetch(val, 1, __ATOMIC_SEQ_CST); } while (0)
>                                          ^
>src/mux_h2.c:2613:3: warning: large atomic operation may incur significant performance penalty [-Watomic-alignment]
>                HA_ATOMIC_INC(&h2c->px_counters->conn_proto_err);
>                ^
>include/haproxy/atomic.h:317:43: note: expanded from macro 'HA_ATOMIC_INC'
>#define HA_ATOMIC_INC(val)           do { __atomic_add_fetch(val, 1, __ATOMIC_SEQ_CST); } while (0)
>                                          ^
>src/mux_h2.c:2023:2: warning: large atomic operation may incur significant performance penalty [-Watomic-alignment]
>        HA_ATOMIC_INC(&h2c->px_counters->rst_stream_resp);
>        ^
>include/haproxy/atomic.h:317:43: note: expanded from macro 'HA_ATOMIC_INC'
>#define HA_ATOMIC_INC(val)           do { __atomic_add_fetch(val, 1, __ATOMIC_SEQ_CST); } while (0)
>                                          ^
>src/mux_h2.c:1876:3: warning: large atomic operation may incur significant performance penalty [-Watomic-alignment]
>                HA_ATOMIC_INC(&h2c->px_counters->goaway_resp);
>                ^
>include/haproxy/atomic.h:317:43: note: expanded from macro 'HA_ATOMIC_INC'
>#define HA_ATOMIC_INC(val)           do { __atomic_add_fetch(val, 1, __ATOMIC_SEQ_CST); } while (0)
>                                          ^
>src/mux_h2.c:1113:3: warning: large atomic operation may incur significant performance penalty [-Watomic-alignment]
>                HA_ATOMIC_DEC(&h2c->px_counters->open_conns);
>                ^
>include/haproxy/atomic.h:318:43: note: expanded from macro 'HA_ATOMIC_DEC'
>#define HA_ATOMIC_DEC(val)           do { __atomic_sub_fetch(val, 1, __ATOMIC_SEQ_CST); } while (0)
>                                          ^
>src/mux_h2.c:1029:2: warning: large atomic operation may incur significant performance penalty [-Watomic-alignment]
>        HA_ATOMIC_INC(&h2c->px_counters->open_conns);
>        ^
>include/haproxy/atomic.h:317:43: note: expanded from macro 'HA_ATOMIC_INC'
>#define HA_ATOMIC_INC(val)           do { __atomic_add_fetch(val, 1, __ATOMIC_SEQ_CST); } while (0)
>                                          ^
>src/mux_h2.c:1030:2: warning: large atomic operation may incur significant performance penalty [-Watomic-alignment]
>        HA_ATOMIC_INC(&h2c->px_counters->total_conns);
>        ^
>include/haproxy/atomic.h:317:43: note: expanded from macro 'HA_ATOMIC_INC'
>#define HA_ATOMIC_INC(val)           do { __atomic_add_fetch(val, 1, __ATOMIC_SEQ_CST); } while (0)
>                                          ^
>39 warnings generated.
>  CC      src/mux_fcgi.o
>  CC      src/http_ana.o
>src/http_ana.c:216:3: warning: large atomic operation may incur significant performance penalty [-Watomic-alignment]
>                _HA_ATOMIC_INC(&sess->fe->fe_counters.intercepted_req);
>                ^
>include/haproxy/atomic.h:439:44: note: expanded from macro '_HA_ATOMIC_INC'
>#define _HA_ATOMIC_INC(val)           do { __atomic_add_fetch(val, 1, __ATOMIC_RELAXED); } while (0)
>                                           ^
>src/http_ana.c:314:2: warning: large atomic operation may incur significant performance penalty [-Watomic-alignment]
>        _HA_ATOMIC_INC(&sess->fe->fe_counters.internal_errors);
>        ^
>include/haproxy/atomic.h:439:44: note: expanded from macro '_HA_ATOMIC_INC'
>#define _HA_ATOMIC_INC(val)           do { __atomic_add_fetch(val, 1, __ATOMIC_RELAXED); } while (0)
>                                           ^
>src/http_ana.c:316:3: warning: large atomic operation may incur significant performance penalty [-Watomic-alignment]
>                _HA_ATOMIC_INC(&sess->listener->counters->internal_errors);
>                ^
>include/haproxy/atomic.h:439:44: note: expanded from macro '_HA_ATOMIC_INC'
>#define _HA_ATOMIC_INC(val)           do { __atomic_add_fetch(val, 1, __ATOMIC_RELAXED); } while (0)
>                                           ^
>src/http_ana.c:321:2: warning: large atomic operation may incur significant performance penalty [-Watomic-alignment]
>        _HA_ATOMIC_INC(&sess->fe->fe_counters.failed_req);
>        ^
>include/haproxy/atomic.h:439:44: note: expanded from macro '_HA_ATOMIC_INC'
>#define _HA_ATOMIC_INC(val)           do { __atomic_add_fetch(val, 1, __ATOMIC_RELAXED); } while (0)
>                                           ^
>src/http_ana.c:323:3: warning: large atomic operation may incur significant performance penalty [-Watomic-alignment]
>                _HA_ATOMIC_INC(&sess->listener->counters->failed_req);
>                ^
>include/haproxy/atomic.h:439:44: note: expanded from macro '_HA_ATOMIC_INC'
>#define _HA_ATOMIC_INC(val)           do { __atomic_add_fetch(val, 1, __ATOMIC_RELAXED); } while (0)
>                                           ^
>src/http_ana.c:444:4: warning: large atomic operation may incur significant performance penalty [-Watomic-alignment]
>                        _HA_ATOMIC_INC(&sess->fe->fe_counters.intercepted_req);
>                        ^
>include/haproxy/atomic.h:439:44: note: expanded from macro '_HA_ATOMIC_INC'
>#define _HA_ATOMIC_INC(val)           do { __atomic_add_fetch(val, 1, __ATOMIC_RELAXED); } while (0)
>                                           ^
>src/http_ana.c:526:2: warning: large atomic operation may incur significant performance penalty [-Watomic-alignment]
>        _HA_ATOMIC_INC(&sess->fe->fe_counters.denied_req);
>        ^
>include/haproxy/atomic.h:439:44: note: expanded from macro '_HA_ATOMIC_INC'
>#define _HA_ATOMIC_INC(val)           do { __atomic_add_fetch(val, 1, __ATOMIC_RELAXED); } while (0)
>                                           ^
>src/http_ana.c:528:3: warning: large atomic operation may incur significant performance penalty [-Watomic-alignment]
>                _HA_ATOMIC_INC(&s->be->be_counters.denied_req);
>                ^
>include/haproxy/atomic.h:439:44: note: expanded from macro '_HA_ATOMIC_INC'
>#define _HA_ATOMIC_INC(val)           do { __atomic_add_fetch(val, 1, __ATOMIC_RELAXED); } while (0)
>                                           ^
>src/http_ana.c:530:3: warning: large atomic operation may incur significant performance penalty [-Watomic-alignment]
>                _HA_ATOMIC_INC(&sess->listener->counters->denied_req);
>                ^
>include/haproxy/atomic.h:439:44: note: expanded from macro '_HA_ATOMIC_INC'
>#define _HA_ATOMIC_INC(val)           do { __atomic_add_fetch(val, 1, __ATOMIC_RELAXED); } while (0)
>                                           ^
>src/http_ana.c:542:2: warning: large atomic operation may incur significant performance penalty [-Watomic-alignment]
>        _HA_ATOMIC_INC(&sess->fe->fe_counters.denied_req);
>        ^
>include/haproxy/atomic.h:439:44: note: expanded from macro '_HA_ATOMIC_INC'
>#define _HA_ATOMIC_INC(val)           do { __atomic_add_fetch(val, 1, __ATOMIC_RELAXED); } while (0)
>                                           ^
>src/http_ana.c:544:3: warning: large atomic operation may incur significant performance penalty [-Watomic-alignment]
>                _HA_ATOMIC_INC(&s->be->be_counters.denied_req);
>                ^
>include/haproxy/atomic.h:439:44: note: expanded from macro '_HA_ATOMIC_INC'
>#define _HA_ATOMIC_INC(val)           do { __atomic_add_fetch(val, 1, __ATOMIC_RELAXED); } while (0)
>                                           ^
>src/http_ana.c:546:3: warning: large atomic operation may incur significant performance penalty [-Watomic-alignment]
>                _HA_ATOMIC_INC(&sess->listener->counters->denied_req);
>                ^
>include/haproxy/atomic.h:439:44: note: expanded from macro '_HA_ATOMIC_INC'
>#define _HA_ATOMIC_INC(val)           do { __atomic_add_fetch(val, 1, __ATOMIC_RELAXED); } while (0)
>                                           ^
>src/http_ana.c:553:2: warning: large atomic operation may incur significant performance penalty [-Watomic-alignment]
>        _HA_ATOMIC_INC(&sess->fe->fe_counters.internal_errors);
>        ^
>include/haproxy/atomic.h:439:44: note: expanded from macro '_HA_ATOMIC_INC'
>#define _HA_ATOMIC_INC(val)           do { __atomic_add_fetch(val, 1, __ATOMIC_RELAXED); } while (0)
>                                           ^
>src/http_ana.c:555:3: warning: large atomic operation may incur significant performance penalty [-Watomic-alignment]
>                _HA_ATOMIC_INC(&s->be->be_counters.internal_errors);
>                ^
>include/haproxy/atomic.h:439:44: note: expanded from macro '_HA_ATOMIC_INC'
>#define _HA_ATOMIC_INC(val)           do { __atomic_add_fetch(val, 1, __ATOMIC_RELAXED); } while (0)
>                                           ^
>src/http_ana.c:557:3: warning: large atomic operation may incur significant performance penalty [-Watomic-alignment]
>                _HA_ATOMIC_INC(&sess->listener->counters->internal_errors);
>                ^
>include/haproxy/atomic.h:439:44: note: expanded from macro '_HA_ATOMIC_INC'
>#define _HA_ATOMIC_INC(val)           do { __atomic_add_fetch(val, 1, __ATOMIC_RELAXED); } while (0)
>                                           ^
>src/http_ana.c:562:2: warning: large atomic operation may incur significant performance penalty [-Watomic-alignment]
>        _HA_ATOMIC_INC(&sess->fe->fe_counters.failed_req);
>        ^
>include/haproxy/atomic.h:439:44: note: expanded from macro '_HA_ATOMIC_INC'
>#define _HA_ATOMIC_INC(val)           do { __atomic_add_fetch(val, 1, __ATOMIC_RELAXED); } while (0)
>                                           ^
>src/http_ana.c:564:3: warning: large atomic operation may incur significant performance penalty [-Watomic-alignment]
>                _HA_ATOMIC_INC(&sess->listener->counters->failed_req);
>                ^
>include/haproxy/atomic.h:439:44: note: expanded from macro '_HA_ATOMIC_INC'
>#define _HA_ATOMIC_INC(val)           do { __atomic_add_fetch(val, 1, __ATOMIC_RELAXED); } while (0)
>                                           ^
>src/http_ana.c:826:2: warning: large atomic operation may incur significant performance penalty [-Watomic-alignment]
>        _HA_ATOMIC_INC(&sess->fe->fe_counters.internal_errors);
>        ^
>include/haproxy/atomic.h:439:44: note: expanded from macro '_HA_ATOMIC_INC'
>#define _HA_ATOMIC_INC(val)           do { __atomic_add_fetch(val, 1, __ATOMIC_RELAXED); } while (0)
>                                           ^
>src/http_ana.c:828:3: warning: large atomic operation may incur significant performance penalty [-Watomic-alignment]
>                _HA_ATOMIC_INC(&s->be->be_counters.internal_errors);
>                ^
>include/haproxy/atomic.h:439:44: note: expanded from macro '_HA_ATOMIC_INC'
>#define _HA_ATOMIC_INC(val)           do { __atomic_add_fetch(val, 1, __ATOMIC_RELAXED); } while (0)
>                                           ^
>src/http_ana.c:830:3: warning: large atomic operation may incur significant performance penalty [-Watomic-alignment]
>                _HA_ATOMIC_INC(&sess->listener->counters->internal_errors);
>                ^
>include/haproxy/atomic.h:439:44: note: expanded from macro '_HA_ATOMIC_INC'
>#define _HA_ATOMIC_INC(val)           do { __atomic_add_fetch(val, 1, __ATOMIC_RELAXED); } while (0)
>                                           ^
>src/http_ana.c:835:2: warning: large atomic operation may incur significant performance penalty [-Watomic-alignment]
>        _HA_ATOMIC_INC(&sess->fe->fe_counters.failed_req);
>        ^
>include/haproxy/atomic.h:439:44: note: expanded from macro '_HA_ATOMIC_INC'
>#define _HA_ATOMIC_INC(val)           do { __atomic_add_fetch(val, 1, __ATOMIC_RELAXED); } while (0)
>                                           ^
>src/http_ana.c:837:3: warning: large atomic operation may incur significant performance penalty [-Watomic-alignment]
>                _HA_ATOMIC_INC(&sess->listener->counters->failed_req);
>                ^
>include/haproxy/atomic.h:439:44: note: expanded from macro '_HA_ATOMIC_INC'
>#define _HA_ATOMIC_INC(val)           do { __atomic_add_fetch(val, 1, __ATOMIC_RELAXED); } while (0)
>                                           ^
>src/http_ana.c:948:2: warning: large atomic operation may incur significant performance penalty [-Watomic-alignment]
>        _HA_ATOMIC_INC(&sess->fe->fe_counters.internal_errors);
>        ^
>include/haproxy/atomic.h:439:44: note: expanded from macro '_HA_ATOMIC_INC'
>#define _HA_ATOMIC_INC(val)           do { __atomic_add_fetch(val, 1, __ATOMIC_RELAXED); } while (0)
>                                           ^
>src/http_ana.c:950:3: warning: large atomic operation may incur significant performance penalty [-Watomic-alignment]
>                _HA_ATOMIC_INC(&s->be->be_counters.internal_errors);
>                ^
>include/haproxy/atomic.h:439:44: note: expanded from macro '_HA_ATOMIC_INC'
>#define _HA_ATOMIC_INC(val)           do { __atomic_add_fetch(val, 1, __ATOMIC_RELAXED); } while (0)
>                                           ^
>src/http_ana.c:952:3: warning: large atomic operation may incur significant performance penalty [-Watomic-alignment]
>                _HA_ATOMIC_INC(&sess->listener->counters->internal_errors);
>                ^
>include/haproxy/atomic.h:439:44: note: expanded from macro '_HA_ATOMIC_INC'
>#define _HA_ATOMIC_INC(val)           do { __atomic_add_fetch(val, 1, __ATOMIC_RELAXED); } while (0)
>                                           ^
>src/http_ana.c:957:2: warning: large atomic operation may incur significant performance penalty [-Watomic-alignment]
>        _HA_ATOMIC_INC(&sess->fe->fe_counters.failed_req);
>        ^
>include/haproxy/atomic.h:439:44: note: expanded from macro '_HA_ATOMIC_INC'
>#define _HA_ATOMIC_INC(val)           do { __atomic_add_fetch(val, 1, __ATOMIC_RELAXED); } while (0)
>                                           ^
>src/http_ana.c:959:3: warning: large atomic operation may incur significant performance penalty [-Watomic-alignment]
>                _HA_ATOMIC_INC(&sess->listener->counters->failed_req);
>                ^
>include/haproxy/atomic.h:439:44: note: expanded from macro '_HA_ATOMIC_INC'
>#define _HA_ATOMIC_INC(val)           do { __atomic_add_fetch(val, 1, __ATOMIC_RELAXED); } while (0)
>                                           ^
>src/http_ana.c:1196:2: warning: large atomic operation may incur significant performance penalty [-Watomic-alignment]
>        _HA_ATOMIC_INC(&sess->fe->fe_counters.cli_aborts);
>        ^
>include/haproxy/atomic.h:439:44: note: expanded from macro '_HA_ATOMIC_INC'
>#define _HA_ATOMIC_INC(val)           do { __atomic_add_fetch(val, 1, __ATOMIC_RELAXED); } while (0)
>                                           ^
>src/http_ana.c:1197:2: warning: large atomic operation may incur significant performance penalty [-Watomic-alignment]
>        _HA_ATOMIC_INC(&s->be->be_counters.cli_aborts);
>        ^
>include/haproxy/atomic.h:439:44: note: expanded from macro '_HA_ATOMIC_INC'
>#define _HA_ATOMIC_INC(val)           do { __atomic_add_fetch(val, 1, __ATOMIC_RELAXED); } while (0)
>                                           ^
>src/http_ana.c:1199:3: warning: large atomic operation may incur significant performance penalty [-Watomic-alignment]
>                _HA_ATOMIC_INC(&sess->listener->counters->cli_aborts);
>                ^
>include/haproxy/atomic.h:439:44: note: expanded from macro '_HA_ATOMIC_INC'
>#define _HA_ATOMIC_INC(val)           do { __atomic_add_fetch(val, 1, __ATOMIC_RELAXED); } while (0)
>                                           ^
>src/http_ana.c:1201:3: warning: large atomic operation may incur significant performance penalty [-Watomic-alignment]
>                _HA_ATOMIC_INC(&__objt_server(s->target)->counters.cli_aborts);
>                ^
>include/haproxy/atomic.h:439:44: note: expanded from macro '_HA_ATOMIC_INC'
>#define _HA_ATOMIC_INC(val)           do { __atomic_add_fetch(val, 1, __ATOMIC_RELAXED); } while (0)
>                                           ^
>src/http_ana.c:1208:2: warning: large atomic operation may incur significant performance penalty [-Watomic-alignment]
>        _HA_ATOMIC_INC(&sess->fe->fe_counters.srv_aborts);
>        ^
>include/haproxy/atomic.h:439:44: note: expanded from macro '_HA_ATOMIC_INC'
>#define _HA_ATOMIC_INC(val)           do { __atomic_add_fetch(val, 1, __ATOMIC_RELAXED); } while (0)
>                                           ^
>src/http_ana.c:1209:2: warning: large atomic operation may incur significant performance penalty [-Watomic-alignment]
>        _HA_ATOMIC_INC(&s->be->be_counters.srv_aborts);
>        ^
>include/haproxy/atomic.h:439:44: note: expanded from macro '_HA_ATOMIC_INC'
>#define _HA_ATOMIC_INC(val)           do { __atomic_add_fetch(val, 1, __ATOMIC_RELAXED); } while (0)
>                                           ^
>src/http_ana.c:1211:3: warning: large atomic operation may incur significant performance penalty [-Watomic-alignment]
>                _HA_ATOMIC_INC(&sess->listener->counters->srv_aborts);
>                ^
>include/haproxy/atomic.h:439:44: note: expanded from macro '_HA_ATOMIC_INC'
>#define _HA_ATOMIC_INC(val)           do { __atomic_add_fetch(val, 1, __ATOMIC_RELAXED); } while (0)
>                                           ^
>src/http_ana.c:1213:3: warning: large atomic operation may incur significant performance penalty [-Watomic-alignment]
>                _HA_ATOMIC_INC(&__objt_server(s->target)->counters.srv_aborts);
>                ^
>include/haproxy/atomic.h:439:44: note: expanded from macro '_HA_ATOMIC_INC'
>#define _HA_ATOMIC_INC(val)           do { __atomic_add_fetch(val, 1, __ATOMIC_RELAXED); } while (0)
>                                           ^
>src/http_ana.c:1222:2: warning: large atomic operation may incur significant performance penalty [-Watomic-alignment]
>        _HA_ATOMIC_INC(&sess->fe->fe_counters.internal_errors);
>        ^
>include/haproxy/atomic.h:439:44: note: expanded from macro '_HA_ATOMIC_INC'
>#define _HA_ATOMIC_INC(val)           do { __atomic_add_fetch(val, 1, __ATOMIC_RELAXED); } while (0)
>                                           ^
>src/http_ana.c:1223:2: warning: large atomic operation may incur significant performance penalty [-Watomic-alignment]
>        _HA_ATOMIC_INC(&s->be->be_counters.internal_errors);
>        ^
>include/haproxy/atomic.h:439:44: note: expanded from macro '_HA_ATOMIC_INC'
>#define _HA_ATOMIC_INC(val)           do { __atomic_add_fetch(val, 1, __ATOMIC_RELAXED); } while (0)
>                                           ^
>src/http_ana.c:1225:3: warning: large atomic operation may incur significant performance penalty [-Watomic-alignment]
>                _HA_ATOMIC_INC(&sess->listener->counters->internal_errors);
>                ^
>include/haproxy/atomic.h:439:44: note: expanded from macro '_HA_ATOMIC_INC'
>#define _HA_ATOMIC_INC(val)           do { __atomic_add_fetch(val, 1, __ATOMIC_RELAXED); } while (0)
>                                           ^
>src/http_ana.c:1227:3: warning: large atomic operation may incur significant performance penalty [-Watomic-alignment]
>                _HA_ATOMIC_INC(&__objt_server(s->target)->counters.internal_errors);
>                ^
>include/haproxy/atomic.h:439:44: note: expanded from macro '_HA_ATOMIC_INC'
>#define _HA_ATOMIC_INC(val)           do { __atomic_add_fetch(val, 1, __ATOMIC_RELAXED); } while (0)
>                                           ^
>src/http_ana.c:1232:2: warning: large atomic operation may incur significant performance penalty [-Watomic-alignment]
>        _HA_ATOMIC_INC(&sess->fe->fe_counters.failed_req);
>        ^
>include/haproxy/atomic.h:439:44: note: expanded from macro '_HA_ATOMIC_INC'
>#define _HA_ATOMIC_INC(val)           do { __atomic_add_fetch(val, 1, __ATOMIC_RELAXED); } while (0)
>                                           ^
>src/http_ana.c:1234:3: warning: large atomic operation may incur significant performance penalty [-Watomic-alignment]
>                _HA_ATOMIC_INC(&sess->listener->counters->failed_req);
>                ^
>include/haproxy/atomic.h:439:44: note: expanded from macro '_HA_ATOMIC_INC'
>#define _HA_ATOMIC_INC(val)           do { __atomic_add_fetch(val, 1, __ATOMIC_RELAXED); } while (0)
>                                           ^
>src/http_ana.c:1376:4: warning: large atomic operation may incur significant performance penalty [-Watomic-alignment]
>                        _HA_ATOMIC_INC(&s->be->be_counters.failed_resp);
>                        ^
>include/haproxy/atomic.h:439:44: note: expanded from macro '_HA_ATOMIC_INC'
>#define _HA_ATOMIC_INC(val)           do { __atomic_add_fetch(val, 1, __ATOMIC_RELAXED); } while (0)
>                                           ^
>src/http_ana.c:1378:5: warning: large atomic operation may incur significant performance penalty [-Watomic-alignment]
>                                _HA_ATOMIC_INC(&__objt_server(s->target)->counters.failed_resp);
>                                ^
>include/haproxy/atomic.h:439:44: note: expanded from macro '_HA_ATOMIC_INC'
>#define _HA_ATOMIC_INC(val)           do { __atomic_add_fetch(val, 1, __ATOMIC_RELAXED); } while (0)
>                                           ^
>src/http_ana.c:1412:4: warning: large atomic operation may incur significant performance penalty [-Watomic-alignment]
>                        _HA_ATOMIC_INC(&s->be->be_counters.failed_resp);
>                        ^
>include/haproxy/atomic.h:439:44: note: expanded from macro '_HA_ATOMIC_INC'
>#define _HA_ATOMIC_INC(val)           do { __atomic_add_fetch(val, 1, __ATOMIC_RELAXED); } while (0)
>                                           ^
>src/http_ana.c:1414:5: warning: large atomic operation may incur significant performance penalty [-Watomic-alignment]
>                                _HA_ATOMIC_INC(&__objt_server(s->target)->counters.failed_resp);
>                                ^
>include/haproxy/atomic.h:439:44: note: expanded from macro '_HA_ATOMIC_INC'
>#define _HA_ATOMIC_INC(val)           do { __atomic_add_fetch(val, 1, __ATOMIC_RELAXED); } while (0)
>                                           ^
>src/http_ana.c:1434:4: warning: large atomic operation may incur significant performance penalty [-Watomic-alignment]
>                        _HA_ATOMIC_INC(&sess->fe->fe_counters.cli_aborts);
>                        ^
>include/haproxy/atomic.h:439:44: note: expanded from macro '_HA_ATOMIC_INC'
>#define _HA_ATOMIC_INC(val)           do { __atomic_add_fetch(val, 1, __ATOMIC_RELAXED); } while (0)
>                                           ^
>src/http_ana.c:1435:4: warning: large atomic operation may incur significant performance penalty [-Watomic-alignment]
>                        _HA_ATOMIC_INC(&s->be->be_counters.cli_aborts);
>                        ^
>include/haproxy/atomic.h:439:44: note: expanded from macro '_HA_ATOMIC_INC'
>#define _HA_ATOMIC_INC(val)           do { __atomic_add_fetch(val, 1, __ATOMIC_RELAXED); } while (0)
>                                           ^
>src/http_ana.c:1437:5: warning: large atomic operation may incur significant performance penalty [-Watomic-alignment]
>                                _HA_ATOMIC_INC(&sess->listener->counters->cli_aborts);
>                                ^
>include/haproxy/atomic.h:439:44: note: expanded from macro '_HA_ATOMIC_INC'
>#define _HA_ATOMIC_INC(val)           do { __atomic_add_fetch(val, 1, __ATOMIC_RELAXED); } while (0)
>                                           ^
>src/http_ana.c:1439:5: warning: large atomic operation may incur significant performance penalty [-Watomic-alignment]
>                                _HA_ATOMIC_INC(&__objt_server(s->target)->counters.cli_aborts);
>                                ^
>include/haproxy/atomic.h:439:44: note: expanded from macro '_HA_ATOMIC_INC'
>#define _HA_ATOMIC_INC(val)           do { __atomic_add_fetch(val, 1, __ATOMIC_RELAXED); } while (0)
>                                           ^
>src/http_ana.c:1469:4: warning: large atomic operation may incur significant performance penalty [-Watomic-alignment]
>                        _HA_ATOMIC_INC(&s->be->be_counters.failed_resp);
>                        ^
>include/haproxy/atomic.h:439:44: note: expanded from macro '_HA_ATOMIC_INC'
>#define _HA_ATOMIC_INC(val)           do { __atomic_add_fetch(val, 1, __ATOMIC_RELAXED); } while (0)
>                                           ^
>src/http_ana.c:1471:5: warning: large atomic operation may incur significant performance penalty [-Watomic-alignment]
>                                _HA_ATOMIC_INC(&__objt_server(s->target)->counters.failed_resp);
>                                ^
>include/haproxy/atomic.h:439:44: note: expanded from macro '_HA_ATOMIC_INC'
>#define _HA_ATOMIC_INC(val)           do { __atomic_add_fetch(val, 1, __ATOMIC_RELAXED); } while (0)
>                                           ^
>src/http_ana.c:1494:4: warning: large atomic operation may incur significant performance penalty [-Watomic-alignment]
>                        _HA_ATOMIC_INC(&s->be->be_counters.failed_resp);
>                        ^
>include/haproxy/atomic.h:439:44: note: expanded from macro '_HA_ATOMIC_INC'
>#define _HA_ATOMIC_INC(val)           do { __atomic_add_fetch(val, 1, __ATOMIC_RELAXED); } while (0)
>                                           ^
>src/http_ana.c:1496:5: warning: large atomic operation may incur significant performance penalty [-Watomic-alignment]
>                                _HA_ATOMIC_INC(&__objt_server(s->target)->counters.failed_resp);
>                                ^
>include/haproxy/atomic.h:439:44: note: expanded from macro '_HA_ATOMIC_INC'
>#define _HA_ATOMIC_INC(val)           do { __atomic_add_fetch(val, 1, __ATOMIC_RELAXED); } while (0)
>                                           ^
>src/http_ana.c:1592:3: warning: large atomic operation may incur significant performance penalty [-Watomic-alignment]
>                _HA_ATOMIC_INC(&__objt_server(s->target)->counters.p.http.rsp[n]);
>                ^
>include/haproxy/atomic.h:439:44: note: expanded from macro '_HA_ATOMIC_INC'
>#define _HA_ATOMIC_INC(val)           do { __atomic_add_fetch(val, 1, __ATOMIC_RELAXED); } while (0)
>                                           ^
>src/http_ana.c:1593:3: warning: large atomic operation may incur significant performance penalty [-Watomic-alignment]
>                _HA_ATOMIC_INC(&__objt_server(s->target)->counters.p.http.cum_req);
>                ^
>include/haproxy/atomic.h:439:44: note: expanded from macro '_HA_ATOMIC_INC'
>#define _HA_ATOMIC_INC(val)           do { __atomic_add_fetch(val, 1, __ATOMIC_RELAXED); } while (0)
>                                           ^
>src/http_ana.c:1736:2: warning: large atomic operation may incur significant performance penalty [-Watomic-alignment]
>        _HA_ATOMIC_INC(&sess->fe->fe_counters.internal_errors);
>        ^
>include/haproxy/atomic.h:439:44: note: expanded from macro '_HA_ATOMIC_INC'
>#define _HA_ATOMIC_INC(val)           do { __atomic_add_fetch(val, 1, __ATOMIC_RELAXED); } while (0)
>                                           ^
>src/http_ana.c:1737:2: warning: large atomic operation may incur significant performance penalty [-Watomic-alignment]
>        _HA_ATOMIC_INC(&s->be->be_counters.internal_errors);
>        ^
>include/haproxy/atomic.h:439:44: note: expanded from macro '_HA_ATOMIC_INC'
>#define _HA_ATOMIC_INC(val)           do { __atomic_add_fetch(val, 1, __ATOMIC_RELAXED); } while (0)
>                                           ^
>src/http_ana.c:1739:3: warning: large atomic operation may incur significant performance penalty [-Watomic-alignment]
>                _HA_ATOMIC_INC(&sess->listener->counters->internal_errors);
>                ^
>include/haproxy/atomic.h:439:44: note: expanded from macro '_HA_ATOMIC_INC'
>#define _HA_ATOMIC_INC(val)           do { __atomic_add_fetch(val, 1, __ATOMIC_RELAXED); } while (0)
>                                           ^
>src/http_ana.c:1741:3: warning: large atomic operation may incur significant performance penalty [-Watomic-alignment]
>                _HA_ATOMIC_INC(&__objt_server(s->target)->counters.internal_errors);
>                ^
>include/haproxy/atomic.h:439:44: note: expanded from macro '_HA_ATOMIC_INC'
>#define _HA_ATOMIC_INC(val)           do { __atomic_add_fetch(val, 1, __ATOMIC_RELAXED); } while (0)
>                                           ^
>src/http_ana.c:1748:2: warning: large atomic operation may incur significant performance penalty [-Watomic-alignment]
>        _HA_ATOMIC_INC(&s->be->be_counters.failed_resp);
>        ^
>include/haproxy/atomic.h:439:44: note: expanded from macro '_HA_ATOMIC_INC'
>#define _HA_ATOMIC_INC(val)           do { __atomic_add_fetch(val, 1, __ATOMIC_RELAXED); } while (0)
>                                           ^
>src/http_ana.c:1750:3: warning: large atomic operation may incur significant performance penalty [-Watomic-alignment]
>                _HA_ATOMIC_INC(&__objt_server(s->target)->counters.failed_resp);
>                ^
>include/haproxy/atomic.h:439:44: note: expanded from macro '_HA_ATOMIC_INC'
>#define _HA_ATOMIC_INC(val)           do { __atomic_add_fetch(val, 1, __ATOMIC_RELAXED); } while (0)
>                                           ^
>src/http_ana.c:2038:2: warning: large atomic operation may incur significant performance penalty [-Watomic-alignment]
>        _HA_ATOMIC_INC(&sess->fe->fe_counters.denied_resp);
>        ^
>include/haproxy/atomic.h:439:44: note: expanded from macro '_HA_ATOMIC_INC'
>#define _HA_ATOMIC_INC(val)           do { __atomic_add_fetch(val, 1, __ATOMIC_RELAXED); } while (0)
>                                           ^
>src/http_ana.c:2039:2: warning: large atomic operation may incur significant performance penalty [-Watomic-alignment]
>        _HA_ATOMIC_INC(&s->be->be_counters.denied_resp);
>        ^
>include/haproxy/atomic.h:439:44: note: expanded from macro '_HA_ATOMIC_INC'
>#define _HA_ATOMIC_INC(val)           do { __atomic_add_fetch(val, 1, __ATOMIC_RELAXED); } while (0)
>                                           ^
>src/http_ana.c:2041:3: warning: large atomic operation may incur significant performance penalty [-Watomic-alignment]
>                _HA_ATOMIC_INC(&sess->listener->counters->denied_resp);
>                ^
>include/haproxy/atomic.h:439:44: note: expanded from macro '_HA_ATOMIC_INC'
>#define _HA_ATOMIC_INC(val)           do { __atomic_add_fetch(val, 1, __ATOMIC_RELAXED); } while (0)
>                                           ^
>src/http_ana.c:2043:3: warning: large atomic operation may incur significant performance penalty [-Watomic-alignment]
>                _HA_ATOMIC_INC(&__objt_server(s->target)->counters.denied_resp);
>                ^
>include/haproxy/atomic.h:439:44: note: expanded from macro '_HA_ATOMIC_INC'
>#define _HA_ATOMIC_INC(val)           do { __atomic_add_fetch(val, 1, __ATOMIC_RELAXED); } while (0)
>                                           ^
>src/http_ana.c:2050:2: warning: large atomic operation may incur significant performance penalty [-Watomic-alignment]
>        _HA_ATOMIC_INC(&sess->fe->fe_counters.internal_errors);
>        ^
>include/haproxy/atomic.h:439:44: note: expanded from macro '_HA_ATOMIC_INC'
>#define _HA_ATOMIC_INC(val)           do { __atomic_add_fetch(val, 1, __ATOMIC_RELAXED); } while (0)
>                                           ^
>src/http_ana.c:2051:2: warning: large atomic operation may incur significant performance penalty [-Watomic-alignment]
>        _HA_ATOMIC_INC(&s->be->be_counters.internal_errors);
>        ^
>include/haproxy/atomic.h:439:44: note: expanded from macro '_HA_ATOMIC_INC'
>#define _HA_ATOMIC_INC(val)           do { __atomic_add_fetch(val, 1, __ATOMIC_RELAXED); } while (0)
>                                           ^
>src/http_ana.c:2053:3: warning: large atomic operation may incur significant performance penalty [-Watomic-alignment]
>                _HA_ATOMIC_INC(&sess->listener->counters->internal_errors);
>                ^
>include/haproxy/atomic.h:439:44: note: expanded from macro '_HA_ATOMIC_INC'
>#define _HA_ATOMIC_INC(val)           do { __atomic_add_fetch(val, 1, __ATOMIC_RELAXED); } while (0)
>                                           ^
>src/http_ana.c:2055:3: warning: large atomic operation may incur significant performance penalty [-Watomic-alignment]
>                _HA_ATOMIC_INC(&__objt_server(s->target)->counters.internal_errors);
>                ^
>include/haproxy/atomic.h:439:44: note: expanded from macro '_HA_ATOMIC_INC'
>#define _HA_ATOMIC_INC(val)           do { __atomic_add_fetch(val, 1, __ATOMIC_RELAXED); } while (0)
>                                           ^
>src/http_ana.c:2061:2: warning: large atomic operation may incur significant performance penalty [-Watomic-alignment]
>        _HA_ATOMIC_INC(&s->be->be_counters.failed_resp);
>        ^
>include/haproxy/atomic.h:439:44: note: expanded from macro '_HA_ATOMIC_INC'
>#define _HA_ATOMIC_INC(val)           do { __atomic_add_fetch(val, 1, __ATOMIC_RELAXED); } while (0)
>                                           ^
>src/http_ana.c:2063:3: warning: large atomic operation may incur significant performance penalty [-Watomic-alignment]
>                _HA_ATOMIC_INC(&__objt_server(s->target)->counters.failed_resp);
>                ^
>include/haproxy/atomic.h:439:44: note: expanded from macro '_HA_ATOMIC_INC'
>#define _HA_ATOMIC_INC(val)           do { __atomic_add_fetch(val, 1, __ATOMIC_RELAXED); } while (0)
>                                           ^
>src/http_ana.c:2305:2: warning: large atomic operation may incur significant performance penalty [-Watomic-alignment]
>        _HA_ATOMIC_INC(&sess->fe->fe_counters.srv_aborts);
>        ^
>include/haproxy/atomic.h:439:44: note: expanded from macro '_HA_ATOMIC_INC'
>#define _HA_ATOMIC_INC(val)           do { __atomic_add_fetch(val, 1, __ATOMIC_RELAXED); } while (0)
>                                           ^
>src/http_ana.c:2306:2: warning: large atomic operation may incur significant performance penalty [-Watomic-alignment]
>        _HA_ATOMIC_INC(&s->be->be_counters.srv_aborts);
>        ^
>include/haproxy/atomic.h:439:44: note: expanded from macro '_HA_ATOMIC_INC'
>#define _HA_ATOMIC_INC(val)           do { __atomic_add_fetch(val, 1, __ATOMIC_RELAXED); } while (0)
>                                           ^
>src/http_ana.c:2308:3: warning: large atomic operation may incur significant performance penalty [-Watomic-alignment]
>                _HA_ATOMIC_INC(&sess->listener->counters->srv_aborts);
>                ^
>include/haproxy/atomic.h:439:44: note: expanded from macro '_HA_ATOMIC_INC'
>#define _HA_ATOMIC_INC(val)           do { __atomic_add_fetch(val, 1, __ATOMIC_RELAXED); } while (0)
>                                           ^
>src/http_ana.c:2310:3: warning: large atomic operation may incur significant performance penalty [-Watomic-alignment]
>                _HA_ATOMIC_INC(&__objt_server(s->target)->counters.srv_aborts);
>                ^
>include/haproxy/atomic.h:439:44: note: expanded from macro '_HA_ATOMIC_INC'
>#define _HA_ATOMIC_INC(val)           do { __atomic_add_fetch(val, 1, __ATOMIC_RELAXED); } while (0)
>                                           ^
>src/http_ana.c:2317:2: warning: large atomic operation may incur significant performance penalty [-Watomic-alignment]
>        _HA_ATOMIC_INC(&sess->fe->fe_counters.cli_aborts);
>        ^
>include/haproxy/atomic.h:439:44: note: expanded from macro '_HA_ATOMIC_INC'
>#define _HA_ATOMIC_INC(val)           do { __atomic_add_fetch(val, 1, __ATOMIC_RELAXED); } while (0)
>                                           ^
>src/http_ana.c:2318:2: warning: large atomic operation may incur significant performance penalty [-Watomic-alignment]
>        _HA_ATOMIC_INC(&s->be->be_counters.cli_aborts);
>        ^
>include/haproxy/atomic.h:439:44: note: expanded from macro '_HA_ATOMIC_INC'
>#define _HA_ATOMIC_INC(val)           do { __atomic_add_fetch(val, 1, __ATOMIC_RELAXED); } while (0)
>                                           ^
>src/http_ana.c:2320:3: warning: large atomic operation may incur significant performance penalty [-Watomic-alignment]
>                _HA_ATOMIC_INC(&sess->listener->counters->cli_aborts);
>                ^
>include/haproxy/atomic.h:439:44: note: expanded from macro '_HA_ATOMIC_INC'
>#define _HA_ATOMIC_INC(val)           do { __atomic_add_fetch(val, 1, __ATOMIC_RELAXED); } while (0)
>                                           ^
>src/http_ana.c:2322:3: warning: large atomic operation may incur significant performance penalty [-Watomic-alignment]
>                _HA_ATOMIC_INC(&__objt_server(s->target)->counters.cli_aborts);
>                ^
>include/haproxy/atomic.h:439:44: note: expanded from macro '_HA_ATOMIC_INC'
>#define _HA_ATOMIC_INC(val)           do { __atomic_add_fetch(val, 1, __ATOMIC_RELAXED); } while (0)
>                                           ^
>src/http_ana.c:2328:2: warning: large atomic operation may incur significant performance penalty [-Watomic-alignment]
>        _HA_ATOMIC_INC(&sess->fe->fe_counters.internal_errors);
>        ^
>include/haproxy/atomic.h:439:44: note: expanded from macro '_HA_ATOMIC_INC'
>#define _HA_ATOMIC_INC(val)           do { __atomic_add_fetch(val, 1, __ATOMIC_RELAXED); } while (0)
>                                           ^
>src/http_ana.c:2329:2: warning: large atomic operation may incur significant performance penalty [-Watomic-alignment]
>        _HA_ATOMIC_INC(&s->be->be_counters.internal_errors);
>        ^
>include/haproxy/atomic.h:439:44: note: expanded from macro '_HA_ATOMIC_INC'
>#define _HA_ATOMIC_INC(val)           do { __atomic_add_fetch(val, 1, __ATOMIC_RELAXED); } while (0)
>                                           ^
>src/http_ana.c:2331:3: warning: large atomic operation may incur significant performance penalty [-Watomic-alignment]
>                _HA_ATOMIC_INC(&sess->listener->counters->internal_errors);
>                ^
>include/haproxy/atomic.h:439:44: note: expanded from macro '_HA_ATOMIC_INC'
>#define _HA_ATOMIC_INC(val)           do { __atomic_add_fetch(val, 1, __ATOMIC_RELAXED); } while (0)
>                                           ^
>src/http_ana.c:2333:3: warning: large atomic operation may incur significant performance penalty [-Watomic-alignment]
>                _HA_ATOMIC_INC(&__objt_server(s->target)->counters.internal_errors);
>                ^
>include/haproxy/atomic.h:439:44: note: expanded from macro '_HA_ATOMIC_INC'
>#define _HA_ATOMIC_INC(val)           do { __atomic_add_fetch(val, 1, __ATOMIC_RELAXED); } while (0)
>                                           ^
>src/http_ana.c:2339:2: warning: large atomic operation may incur significant performance penalty [-Watomic-alignment]
>        _HA_ATOMIC_INC(&s->be->be_counters.failed_resp);
>        ^
>include/haproxy/atomic.h:439:44: note: expanded from macro '_HA_ATOMIC_INC'
>#define _HA_ATOMIC_INC(val)           do { __atomic_add_fetch(val, 1, __ATOMIC_RELAXED); } while (0)
>                                           ^
>src/http_ana.c:2341:3: warning: large atomic operation may incur significant performance penalty [-Watomic-alignment]
>                _HA_ATOMIC_INC(&__objt_server(s->target)->counters.failed_resp);
>                ^
>include/haproxy/atomic.h:439:44: note: expanded from macro '_HA_ATOMIC_INC'
>#define _HA_ATOMIC_INC(val)           do { __atomic_add_fetch(val, 1, __ATOMIC_RELAXED); } while (0)
>                                           ^
>src/http_ana.c:2579:4: warning: large atomic operation may incur significant performance penalty [-Watomic-alignment]
>                        _HA_ATOMIC_INC(&s->sess->fe->fe_counters.intercepted_req);
>                        ^
>include/haproxy/atomic.h:439:44: note: expanded from macro '_HA_ATOMIC_INC'
>#define _HA_ATOMIC_INC(val)           do { __atomic_add_fetch(val, 1, __ATOMIC_RELAXED); } while (0)
>                                           ^
>src/http_ana.c:4159:2: warning: large atomic operation may incur significant performance penalty [-Watomic-alignment]
>        _HA_ATOMIC_INC(&sess->fe->fe_counters.failed_req);
>        ^
>include/haproxy/atomic.h:439:44: note: expanded from macro '_HA_ATOMIC_INC'
>#define _HA_ATOMIC_INC(val)           do { __atomic_add_fetch(val, 1, __ATOMIC_RELAXED); } while (0)
>                                           ^
>src/http_ana.c:4161:3: warning: large atomic operation may incur significant performance penalty [-Watomic-alignment]
>                _HA_ATOMIC_INC(&sess->listener->counters->failed_req);
>                ^
>include/haproxy/atomic.h:439:44: note: expanded from macro '_HA_ATOMIC_INC'
>#define _HA_ATOMIC_INC(val)           do { __atomic_add_fetch(val, 1, __ATOMIC_RELAXED); } while (0)
>                                           ^
>In file included from src/http_ana.c:31:
>include/haproxy/proxy.h:154:2: warning: large atomic operation may incur significant performance penalty [-Watomic-alignment]
>        _HA_ATOMIC_INC(&fe->fe_counters.p.http.cum_req);
>        ^
>include/haproxy/atomic.h:439:44: note: expanded from macro '_HA_ATOMIC_INC'
>#define _HA_ATOMIC_INC(val)           do { __atomic_add_fetch(val, 1, __ATOMIC_RELAXED); } while (0)
>                                           ^
>In file included from src/http_ana.c:31:
>include/haproxy/proxy.h:156:3: warning: large atomic operation may incur significant performance penalty [-Watomic-alignment]
>                _HA_ATOMIC_INC(&l->counters->p.http.cum_req);
>                ^
>include/haproxy/atomic.h:439:44: note: expanded from macro '_HA_ATOMIC_INC'
>#define _HA_ATOMIC_INC(val)           do { __atomic_add_fetch(val, 1, __ATOMIC_RELAXED); } while (0)
>                                           ^
>src/http_ana.c:1271:3: warning: large atomic operation may incur significant performance penalty [-Watomic-alignment]
>                _HA_ATOMIC_INC(&__objt_server(s->target)->counters.retries);
>                ^
>include/haproxy/atomic.h:439:44: note: expanded from macro '_HA_ATOMIC_INC'
>#define _HA_ATOMIC_INC(val)           do { __atomic_add_fetch(val, 1, __ATOMIC_RELAXED); } while (0)
>                                           ^
>src/http_ana.c:1273:2: warning: large atomic operation may incur significant performance penalty [-Watomic-alignment]
>        _HA_ATOMIC_INC(&s->be->be_counters.retries);
>        ^
>include/haproxy/atomic.h:439:44: note: expanded from macro '_HA_ATOMIC_INC'
>#define _HA_ATOMIC_INC(val)           do { __atomic_add_fetch(val, 1, __ATOMIC_RELAXED); } while (0)
>                                           ^
>In file included from src/http_ana.c:20:
>In file included from include/haproxy/channel.h:30:
>include/haproxy/stream.h:348:4: warning: large atomic operation may incur significant performance penalty [-Watomic-alignment]
>                        _HA_ATOMIC_INC(&__objt_server(s->target)->counters.retries);
>                        ^
>include/haproxy/atomic.h:439:44: note: expanded from macro '_HA_ATOMIC_INC'
>#define _HA_ATOMIC_INC(val)           do { __atomic_add_fetch(val, 1, __ATOMIC_RELAXED); } while (0)
>                                           ^
>In file included from src/http_ana.c:20:
>In file included from include/haproxy/channel.h:30:
>include/haproxy/stream.h:349:3: warning: large atomic operation may incur significant performance penalty [-Watomic-alignment]
>                _HA_ATOMIC_INC(&s->be->be_counters.retries);
>                ^
>include/haproxy/atomic.h:439:44: note: expanded from macro '_HA_ATOMIC_INC'
>#define _HA_ATOMIC_INC(val)           do { __atomic_add_fetch(val, 1, __ATOMIC_RELAXED); } while (0)
>                                           ^
>In file included from src/http_ana.c:22:
>In file included from include/haproxy/connection.h:35:
>In file included from include/haproxy/session.h:29:
>include/haproxy/server.h:166:2: warning: large atomic operation may incur significant performance penalty [-Watomic-alignment]
>        _HA_ATOMIC_INC(&s->counters.cum_sess);
>        ^
>include/haproxy/atomic.h:439:44: note: expanded from macro '_HA_ATOMIC_INC'
>#define _HA_ATOMIC_INC(val)           do { __atomic_add_fetch(val, 1, __ATOMIC_RELAXED); } while (0)
>                                           ^
>src/http_ana.c:4476:4: warning: large atomic operation may incur significant performance penalty [-Watomic-alignment]
>                        _HA_ATOMIC_INC(&strm_sess(s)->fe->fe_counters.cli_aborts);
>                        ^
>include/haproxy/atomic.h:439:44: note: expanded from macro '_HA_ATOMIC_INC'
>#define _HA_ATOMIC_INC(val)           do { __atomic_add_fetch(val, 1, __ATOMIC_RELAXED); } while (0)
>                                           ^
>src/http_ana.c:4477:4: warning: large atomic operation may incur significant performance penalty [-Watomic-alignment]
>                        _HA_ATOMIC_INC(&s->be->be_counters.cli_aborts);
>                        ^
>include/haproxy/atomic.h:439:44: note: expanded from macro '_HA_ATOMIC_INC'
>#define _HA_ATOMIC_INC(val)           do { __atomic_add_fetch(val, 1, __ATOMIC_RELAXED); } while (0)
>                                           ^
>src/http_ana.c:4479:5: warning: large atomic operation may incur significant performance penalty [-Watomic-alignment]
>                                _HA_ATOMIC_INC(&strm_sess(s)->listener->counters->cli_aborts);
>                                ^
>include/haproxy/atomic.h:439:44: note: expanded from macro '_HA_ATOMIC_INC'
>#define _HA_ATOMIC_INC(val)           do { __atomic_add_fetch(val, 1, __ATOMIC_RELAXED); } while (0)
>                                           ^
>src/http_ana.c:4481:5: warning: large atomic operation may incur significant performance penalty [-Watomic-alignment]
>                                _HA_ATOMIC_INC(&__objt_server(s->target)->counters.cli_aborts);
>                                ^
>include/haproxy/atomic.h:439:44: note: expanded from macro '_HA_ATOMIC_INC'
>#define _HA_ATOMIC_INC(val)           do { __atomic_add_fetch(val, 1, __ATOMIC_RELAXED); } while (0)
>                                           ^
>99 warnings generated.
>  CC      src/mux_h1.o
>src/mux_h1.c:2441:2: warning: large atomic operation may incur significant performance penalty [-Watomic-alignment]
>        _HA_ATOMIC_INC(&sess->fe->fe_counters.p.http.rsp[5]);
>        ^
>include/haproxy/atomic.h:439:44: note: expanded from macro '_HA_ATOMIC_INC'
>#define _HA_ATOMIC_INC(val)           do { __atomic_add_fetch(val, 1, __ATOMIC_RELAXED); } while (0)
>                                           ^
>src/mux_h1.c:2442:2: warning: large atomic operation may incur significant performance penalty [-Watomic-alignment]
>        _HA_ATOMIC_INC(&sess->fe->fe_counters.internal_errors);
>        ^
>include/haproxy/atomic.h:439:44: note: expanded from macro '_HA_ATOMIC_INC'
>#define _HA_ATOMIC_INC(val)           do { __atomic_add_fetch(val, 1, __ATOMIC_RELAXED); } while (0)
>                                           ^
>src/mux_h1.c:2444:3: warning: large atomic operation may incur significant performance penalty [-Watomic-alignment]
>                _HA_ATOMIC_INC(&sess->listener->counters->internal_errors);
>                ^
>include/haproxy/atomic.h:439:44: note: expanded from macro '_HA_ATOMIC_INC'
>#define _HA_ATOMIC_INC(val)           do { __atomic_add_fetch(val, 1, __ATOMIC_RELAXED); } while (0)
>                                           ^
>In file included from src/mux_h1.c:25:
>include/haproxy/proxy.h:154:2: warning: large atomic operation may incur significant performance penalty [-Watomic-alignment]
>        _HA_ATOMIC_INC(&fe->fe_counters.p.http.cum_req);
>        ^
>include/haproxy/atomic.h:439:44: note: expanded from macro '_HA_ATOMIC_INC'
>#define _HA_ATOMIC_INC(val)           do { __atomic_add_fetch(val, 1, __ATOMIC_RELAXED); } while (0)
>                                           ^
>In file included from src/mux_h1.c:25:
>include/haproxy/proxy.h:156:3: warning: large atomic operation may incur significant performance penalty [-Watomic-alignment]
>                _HA_ATOMIC_INC(&l->counters->p.http.cum_req);
>                ^
>include/haproxy/atomic.h:439:44: note: expanded from macro '_HA_ATOMIC_INC'
>#define _HA_ATOMIC_INC(val)           do { __atomic_add_fetch(val, 1, __ATOMIC_RELAXED); } while (0)
>                                           ^
>src/mux_h1.c:2466:2: warning: large atomic operation may incur significant performance penalty [-Watomic-alignment]
>        _HA_ATOMIC_INC(&sess->fe->fe_counters.p.http.rsp[4]);
>        ^
>include/haproxy/atomic.h:439:44: note: expanded from macro '_HA_ATOMIC_INC'
>#define _HA_ATOMIC_INC(val)           do { __atomic_add_fetch(val, 1, __ATOMIC_RELAXED); } while (0)
>                                           ^
>src/mux_h1.c:2467:2: warning: large atomic operation may incur significant performance penalty [-Watomic-alignment]
>        _HA_ATOMIC_INC(&sess->fe->fe_counters.failed_req);
>        ^
>include/haproxy/atomic.h:439:44: note: expanded from macro '_HA_ATOMIC_INC'
>#define _HA_ATOMIC_INC(val)           do { __atomic_add_fetch(val, 1, __ATOMIC_RELAXED); } while (0)
>                                           ^
>src/mux_h1.c:2469:3: warning: large atomic operation may incur significant performance penalty [-Watomic-alignment]
>                _HA_ATOMIC_INC(&sess->listener->counters->failed_req);
>                ^
>include/haproxy/atomic.h:439:44: note: expanded from macro '_HA_ATOMIC_INC'
>#define _HA_ATOMIC_INC(val)           do { __atomic_add_fetch(val, 1, __ATOMIC_RELAXED); } while (0)
>                                           ^
>src/mux_h1.c:2494:2: warning: large atomic operation may incur significant performance penalty [-Watomic-alignment]
>        _HA_ATOMIC_INC(&sess->fe->fe_counters.p.http.rsp[4]);
>        ^
>include/haproxy/atomic.h:439:44: note: expanded from macro '_HA_ATOMIC_INC'
>#define _HA_ATOMIC_INC(val)           do { __atomic_add_fetch(val, 1, __ATOMIC_RELAXED); } while (0)
>                                           ^
>src/mux_h1.c:2495:2: warning: large atomic operation may incur significant performance penalty [-Watomic-alignment]
>        _HA_ATOMIC_INC(&sess->fe->fe_counters.failed_req);
>        ^
>include/haproxy/atomic.h:439:44: note: expanded from macro '_HA_ATOMIC_INC'
>#define _HA_ATOMIC_INC(val)           do { __atomic_add_fetch(val, 1, __ATOMIC_RELAXED); } while (0)
>                                           ^
>src/mux_h1.c:2497:3: warning: large atomic operation may incur significant performance penalty [-Watomic-alignment]
>                _HA_ATOMIC_INC(&sess->listener->counters->failed_req);
>                ^
>include/haproxy/atomic.h:439:44: note: expanded from macro '_HA_ATOMIC_INC'
>#define _HA_ATOMIC_INC(val)           do { __atomic_add_fetch(val, 1, __ATOMIC_RELAXED); } while (0)
>                                           ^
>src/mux_h1.c:2521:2: warning: large atomic operation may incur significant performance penalty [-Watomic-alignment]
>        _HA_ATOMIC_INC(&sess->fe->fe_counters.p.http.rsp[4]);
>        ^
>include/haproxy/atomic.h:439:44: note: expanded from macro '_HA_ATOMIC_INC'
>#define _HA_ATOMIC_INC(val)           do { __atomic_add_fetch(val, 1, __ATOMIC_RELAXED); } while (0)
>                                           ^
>src/mux_h1.c:2522:2: warning: large atomic operation may incur significant performance penalty [-Watomic-alignment]
>        _HA_ATOMIC_INC(&sess->fe->fe_counters.failed_req);
>        ^
>include/haproxy/atomic.h:439:44: note: expanded from macro '_HA_ATOMIC_INC'
>#define _HA_ATOMIC_INC(val)           do { __atomic_add_fetch(val, 1, __ATOMIC_RELAXED); } while (0)
>                                           ^
>src/mux_h1.c:2524:3: warning: large atomic operation may incur significant performance penalty [-Watomic-alignment]
>                _HA_ATOMIC_INC(&sess->listener->counters->failed_req);
>                ^
>include/haproxy/atomic.h:439:44: note: expanded from macro '_HA_ATOMIC_INC'
>#define _HA_ATOMIC_INC(val)           do { __atomic_add_fetch(val, 1, __ATOMIC_RELAXED); } while (0)
>                                           ^
>14 warnings generated.
>  CC      src/stream.o
>src/stream.c:823:3: warning: large atomic operation may incur significant performance penalty [-Watomic-alignment]
>                _HA_ATOMIC_ADD(&sess->fe->fe_counters.bytes_in, bytes);
>                ^
>include/haproxy/atomic.h:437:44: note: expanded from macro '_HA_ATOMIC_ADD'
>#define _HA_ATOMIC_ADD(val, i)        do { __atomic_add_fetch(val, i, __ATOMIC_RELAXED); } while (0)
>                                           ^
>src/stream.c:824:3: warning: large atomic operation may incur significant performance penalty [-Watomic-alignment]
>                _HA_ATOMIC_ADD(&s->be->be_counters.bytes_in,    bytes);
>                ^
>include/haproxy/atomic.h:437:44: note: expanded from macro '_HA_ATOMIC_ADD'
>#define _HA_ATOMIC_ADD(val, i)        do { __atomic_add_fetch(val, i, __ATOMIC_RELAXED); } while (0)
>                                           ^
>src/stream.c:827:4: warning: large atomic operation may incur significant performance penalty [-Watomic-alignment]
>                        _HA_ATOMIC_ADD(&objt_server(s->target)->counters.bytes_in, bytes);
>                        ^
>include/haproxy/atomic.h:437:44: note: expanded from macro '_HA_ATOMIC_ADD'
>#define _HA_ATOMIC_ADD(val, i)        do { __atomic_add_fetch(val, i, __ATOMIC_RELAXED); } while (0)
>                                           ^
>src/stream.c:830:4: warning: large atomic operation may incur significant performance penalty [-Watomic-alignment]
>                        _HA_ATOMIC_ADD(&sess->listener->counters->bytes_in, bytes);
>                        ^
>include/haproxy/atomic.h:437:44: note: expanded from macro '_HA_ATOMIC_ADD'
>#define _HA_ATOMIC_ADD(val, i)        do { __atomic_add_fetch(val, i, __ATOMIC_RELAXED); } while (0)
>                                           ^
>src/stream.c:841:3: warning: large atomic operation may incur significant performance penalty [-Watomic-alignment]
>                _HA_ATOMIC_ADD(&sess->fe->fe_counters.bytes_out, bytes);
>                ^
>include/haproxy/atomic.h:437:44: note: expanded from macro '_HA_ATOMIC_ADD'
>#define _HA_ATOMIC_ADD(val, i)        do { __atomic_add_fetch(val, i, __ATOMIC_RELAXED); } while (0)
>                                           ^
>src/stream.c:842:3: warning: large atomic operation may incur significant performance penalty [-Watomic-alignment]
>                _HA_ATOMIC_ADD(&s->be->be_counters.bytes_out,    bytes);
>                ^
>include/haproxy/atomic.h:437:44: note: expanded from macro '_HA_ATOMIC_ADD'
>#define _HA_ATOMIC_ADD(val, i)        do { __atomic_add_fetch(val, i, __ATOMIC_RELAXED); } while (0)
>                                           ^
>src/stream.c:845:4: warning: large atomic operation may incur significant performance penalty [-Watomic-alignment]
>                        _HA_ATOMIC_ADD(&objt_server(s->target)->counters.bytes_out, bytes);
>                        ^
>include/haproxy/atomic.h:437:44: note: expanded from macro '_HA_ATOMIC_ADD'
>#define _HA_ATOMIC_ADD(val, i)        do { __atomic_add_fetch(val, i, __ATOMIC_RELAXED); } while (0)
>                                           ^
>src/stream.c:848:4: warning: large atomic operation may incur significant performance penalty [-Watomic-alignment]
>                        _HA_ATOMIC_ADD(&sess->listener->counters->bytes_out, bytes);
>                        ^
>include/haproxy/atomic.h:437:44: note: expanded from macro '_HA_ATOMIC_ADD'
>#define _HA_ATOMIC_ADD(val, i)        do { __atomic_add_fetch(val, i, __ATOMIC_RELAXED); } while (0)
>                                           ^
>src/stream.c:1035:4: warning: large atomic operation may incur significant performance penalty [-Watomic-alignment]
>                        _HA_ATOMIC_INC(&sess->fe->fe_counters.intercepted_req);
>                        ^
>include/haproxy/atomic.h:439:44: note: expanded from macro '_HA_ATOMIC_INC'
>#define _HA_ATOMIC_INC(val)           do { __atomic_add_fetch(val, 1, __ATOMIC_RELAXED); } while (0)
>                                           ^
>src/stream.c:1738:5: warning: large atomic operation may incur significant performance penalty [-Watomic-alignment]
>                                _HA_ATOMIC_INC(&s->be->be_counters.cli_aborts);
>                                ^
>include/haproxy/atomic.h:439:44: note: expanded from macro '_HA_ATOMIC_INC'
>#define _HA_ATOMIC_INC(val)           do { __atomic_add_fetch(val, 1, __ATOMIC_RELAXED); } while (0)
>                                           ^
>src/stream.c:1739:5: warning: large atomic operation may incur significant performance penalty [-Watomic-alignment]
>                                _HA_ATOMIC_INC(&sess->fe->fe_counters.cli_aborts);
>                                ^
>include/haproxy/atomic.h:439:44: note: expanded from macro '_HA_ATOMIC_INC'
>#define _HA_ATOMIC_INC(val)           do { __atomic_add_fetch(val, 1, __ATOMIC_RELAXED); } while (0)
>                                           ^
>src/stream.c:1741:6: warning: large atomic operation may incur significant performance penalty [-Watomic-alignment]
>                                        _HA_ATOMIC_INC(&sess->listener->counters->cli_aborts);
>                                        ^
>include/haproxy/atomic.h:439:44: note: expanded from macro '_HA_ATOMIC_INC'
>#define _HA_ATOMIC_INC(val)           do { __atomic_add_fetch(val, 1, __ATOMIC_RELAXED); } while (0)
>                                           ^
>src/stream.c:1743:6: warning: large atomic operation may incur significant performance penalty [-Watomic-alignment]
>                                        _HA_ATOMIC_INC(&srv->counters.cli_aborts);
>                                        ^
>include/haproxy/atomic.h:439:44: note: expanded from macro '_HA_ATOMIC_INC'
>#define _HA_ATOMIC_INC(val)           do { __atomic_add_fetch(val, 1, __ATOMIC_RELAXED); } while (0)
>                                           ^
>src/stream.c:1757:4: warning: large atomic operation may incur significant performance penalty [-Watomic-alignment]
>                        _HA_ATOMIC_INC(&s->be->be_counters.failed_resp);
>                        ^
>include/haproxy/atomic.h:439:44: note: expanded from macro '_HA_ATOMIC_INC'
>#define _HA_ATOMIC_INC(val)           do { __atomic_add_fetch(val, 1, __ATOMIC_RELAXED); } while (0)
>                                           ^
>src/stream.c:1759:5: warning: large atomic operation may incur significant performance penalty [-Watomic-alignment]
>                                _HA_ATOMIC_INC(&srv->counters.failed_resp);
>                                ^
>include/haproxy/atomic.h:439:44: note: expanded from macro '_HA_ATOMIC_INC'
>#define _HA_ATOMIC_INC(val)           do { __atomic_add_fetch(val, 1, __ATOMIC_RELAXED); } while (0)
>                                           ^
>src/stream.c:1761:5: warning: large atomic operation may incur significant performance penalty [-Watomic-alignment]
>                                _HA_ATOMIC_INC(&s->be->be_counters.srv_aborts);
>                                ^
>include/haproxy/atomic.h:439:44: note: expanded from macro '_HA_ATOMIC_INC'
>#define _HA_ATOMIC_INC(val)           do { __atomic_add_fetch(val, 1, __ATOMIC_RELAXED); } while (0)
>                                           ^
>src/stream.c:1762:5: warning: large atomic operation may incur significant performance penalty [-Watomic-alignment]
>                                _HA_ATOMIC_INC(&sess->fe->fe_counters.srv_aborts);
>                                ^
>include/haproxy/atomic.h:439:44: note: expanded from macro '_HA_ATOMIC_INC'
>#define _HA_ATOMIC_INC(val)           do { __atomic_add_fetch(val, 1, __ATOMIC_RELAXED); } while (0)
>                                           ^
>src/stream.c:1764:6: warning: large atomic operation may incur significant performance penalty [-Watomic-alignment]
>                                        _HA_ATOMIC_INC(&sess->listener->counters->srv_aborts);
>                                        ^
>include/haproxy/atomic.h:439:44: note: expanded from macro '_HA_ATOMIC_INC'
>#define _HA_ATOMIC_INC(val)           do { __atomic_add_fetch(val, 1, __ATOMIC_RELAXED); } while (0)
>                                           ^
>src/stream.c:1766:6: warning: large atomic operation may incur significant performance penalty [-Watomic-alignment]
>                                        _HA_ATOMIC_INC(&srv->counters.srv_aborts);
>                                        ^
>include/haproxy/atomic.h:439:44: note: expanded from macro '_HA_ATOMIC_INC'
>#define _HA_ATOMIC_INC(val)           do { __atomic_add_fetch(val, 1, __ATOMIC_RELAXED); } while (0)
>                                           ^
>src/stream.c:2016:5: warning: large atomic operation may incur significant performance penalty [-Watomic-alignment]
>                                _HA_ATOMIC_INC(&s->be->be_counters.cli_aborts);
>                                ^
>include/haproxy/atomic.h:439:44: note: expanded from macro '_HA_ATOMIC_INC'
>#define _HA_ATOMIC_INC(val)           do { __atomic_add_fetch(val, 1, __ATOMIC_RELAXED); } while (0)
>                                           ^
>src/stream.c:2017:5: warning: large atomic operation may incur significant performance penalty [-Watomic-alignment]
>                                _HA_ATOMIC_INC(&sess->fe->fe_counters.cli_aborts);
>                                ^
>include/haproxy/atomic.h:439:44: note: expanded from macro '_HA_ATOMIC_INC'
>#define _HA_ATOMIC_INC(val)           do { __atomic_add_fetch(val, 1, __ATOMIC_RELAXED); } while (0)
>                                           ^
>src/stream.c:2019:6: warning: large atomic operation may incur significant performance penalty [-Watomic-alignment]
>                                        _HA_ATOMIC_INC(&sess->listener->counters->cli_aborts);
>                                        ^
>include/haproxy/atomic.h:439:44: note: expanded from macro '_HA_ATOMIC_INC'
>#define _HA_ATOMIC_INC(val)           do { __atomic_add_fetch(val, 1, __ATOMIC_RELAXED); } while (0)
>                                           ^
>src/stream.c:2021:6: warning: large atomic operation may incur significant performance penalty [-Watomic-alignment]
>                                        _HA_ATOMIC_INC(&srv->counters.cli_aborts);
>                                        ^
>include/haproxy/atomic.h:439:44: note: expanded from macro '_HA_ATOMIC_INC'
>#define _HA_ATOMIC_INC(val)           do { __atomic_add_fetch(val, 1, __ATOMIC_RELAXED); } while (0)
>                                           ^
>src/stream.c:2025:5: warning: large atomic operation may incur significant performance penalty [-Watomic-alignment]
>                                _HA_ATOMIC_INC(&s->be->be_counters.cli_aborts);
>                                ^
>include/haproxy/atomic.h:439:44: note: expanded from macro '_HA_ATOMIC_INC'
>#define _HA_ATOMIC_INC(val)           do { __atomic_add_fetch(val, 1, __ATOMIC_RELAXED); } while (0)
>                                           ^
>src/stream.c:2026:5: warning: large atomic operation may incur significant performance penalty [-Watomic-alignment]
>                                _HA_ATOMIC_INC(&sess->fe->fe_counters.cli_aborts);
>                                ^
>include/haproxy/atomic.h:439:44: note: expanded from macro '_HA_ATOMIC_INC'
>#define _HA_ATOMIC_INC(val)           do { __atomic_add_fetch(val, 1, __ATOMIC_RELAXED); } while (0)
>                                           ^
>src/stream.c:2028:6: warning: large atomic operation may incur significant performance penalty [-Watomic-alignment]
>                                        _HA_ATOMIC_INC(&sess->listener->counters->cli_aborts);
>                                        ^
>include/haproxy/atomic.h:439:44: note: expanded from macro '_HA_ATOMIC_INC'
>#define _HA_ATOMIC_INC(val)           do { __atomic_add_fetch(val, 1, __ATOMIC_RELAXED); } while (0)
>                                           ^
>src/stream.c:2030:6: warning: large atomic operation may incur significant performance penalty [-Watomic-alignment]
>                                        _HA_ATOMIC_INC(&srv->counters.cli_aborts);
>                                        ^
>include/haproxy/atomic.h:439:44: note: expanded from macro '_HA_ATOMIC_INC'
>#define _HA_ATOMIC_INC(val)           do { __atomic_add_fetch(val, 1, __ATOMIC_RELAXED); } while (0)
>                                           ^
>src/stream.c:2034:5: warning: large atomic operation may incur significant performance penalty [-Watomic-alignment]
>                                _HA_ATOMIC_INC(&s->be->be_counters.srv_aborts);
>                                ^
>include/haproxy/atomic.h:439:44: note: expanded from macro '_HA_ATOMIC_INC'
>#define _HA_ATOMIC_INC(val)           do { __atomic_add_fetch(val, 1, __ATOMIC_RELAXED); } while (0)
>                                           ^
>src/stream.c:2035:5: warning: large atomic operation may incur significant performance penalty [-Watomic-alignment]
>                                _HA_ATOMIC_INC(&sess->fe->fe_counters.srv_aborts);
>                                ^
>include/haproxy/atomic.h:439:44: note: expanded from macro '_HA_ATOMIC_INC'
>#define _HA_ATOMIC_INC(val)           do { __atomic_add_fetch(val, 1, __ATOMIC_RELAXED); } while (0)
>                                           ^
>src/stream.c:2037:6: warning: large atomic operation may incur significant performance penalty [-Watomic-alignment]
>                                        _HA_ATOMIC_INC(&sess->listener->counters->srv_aborts);
>                                        ^
>include/haproxy/atomic.h:439:44: note: expanded from macro '_HA_ATOMIC_INC'
>#define _HA_ATOMIC_INC(val)           do { __atomic_add_fetch(val, 1, __ATOMIC_RELAXED); } while (0)
>                                           ^
>src/stream.c:2039:6: warning: large atomic operation may incur significant performance penalty [-Watomic-alignment]
>                                        _HA_ATOMIC_INC(&srv->counters.srv_aborts);
>                                        ^
>include/haproxy/atomic.h:439:44: note: expanded from macro '_HA_ATOMIC_INC'
>#define _HA_ATOMIC_INC(val)           do { __atomic_add_fetch(val, 1, __ATOMIC_RELAXED); } while (0)
>                                           ^
>src/stream.c:2043:5: warning: large atomic operation may incur significant performance penalty [-Watomic-alignment]
>                                _HA_ATOMIC_INC(&s->be->be_counters.srv_aborts);
>                                ^
>include/haproxy/atomic.h:439:44: note: expanded from macro '_HA_ATOMIC_INC'
>#define _HA_ATOMIC_INC(val)           do { __atomic_add_fetch(val, 1, __ATOMIC_RELAXED); } while (0)
>                                           ^
>src/stream.c:2044:5: warning: large atomic operation may incur significant performance penalty [-Watomic-alignment]
>                                _HA_ATOMIC_INC(&sess->fe->fe_counters.srv_aborts);
>                                ^
>include/haproxy/atomic.h:439:44: note: expanded from macro '_HA_ATOMIC_INC'
>#define _HA_ATOMIC_INC(val)           do { __atomic_add_fetch(val, 1, __ATOMIC_RELAXED); } while (0)
>                                           ^
>src/stream.c:2046:6: warning: large atomic operation may incur significant performance penalty [-Watomic-alignment]
>                                        _HA_ATOMIC_INC(&sess->listener->counters->srv_aborts);
>                                        ^
>include/haproxy/atomic.h:439:44: note: expanded from macro '_HA_ATOMIC_INC'
>#define _HA_ATOMIC_INC(val)           do { __atomic_add_fetch(val, 1, __ATOMIC_RELAXED); } while (0)
>                                           ^
>src/stream.c:2048:6: warning: large atomic operation may incur significant performance penalty [-Watomic-alignment]
>                                        _HA_ATOMIC_INC(&srv->counters.srv_aborts);
>                                        ^
>include/haproxy/atomic.h:439:44: note: expanded from macro '_HA_ATOMIC_INC'
>#define _HA_ATOMIC_INC(val)           do { __atomic_add_fetch(val, 1, __ATOMIC_RELAXED); } while (0)
>                                           ^
>src/stream.c:2070:5: warning: large atomic operation may incur significant performance penalty [-Watomic-alignment]
>                                _HA_ATOMIC_INC(&s->be->be_counters.srv_aborts);
>                                ^
>include/haproxy/atomic.h:439:44: note: expanded from macro '_HA_ATOMIC_INC'
>#define _HA_ATOMIC_INC(val)           do { __atomic_add_fetch(val, 1, __ATOMIC_RELAXED); } while (0)
>                                           ^
>src/stream.c:2071:5: warning: large atomic operation may incur significant performance penalty [-Watomic-alignment]
>                                _HA_ATOMIC_INC(&sess->fe->fe_counters.srv_aborts);
>                                ^
>include/haproxy/atomic.h:439:44: note: expanded from macro '_HA_ATOMIC_INC'
>#define _HA_ATOMIC_INC(val)           do { __atomic_add_fetch(val, 1, __ATOMIC_RELAXED); } while (0)
>                                           ^
>src/stream.c:2073:6: warning: large atomic operation may incur significant performance penalty [-Watomic-alignment]
>                                        _HA_ATOMIC_INC(&sess->listener->counters->srv_aborts);
>                                        ^
>include/haproxy/atomic.h:439:44: note: expanded from macro '_HA_ATOMIC_INC'
>#define _HA_ATOMIC_INC(val)           do { __atomic_add_fetch(val, 1, __ATOMIC_RELAXED); } while (0)
>                                           ^
>src/stream.c:2075:6: warning: large atomic operation may incur significant performance penalty [-Watomic-alignment]
>                                        _HA_ATOMIC_INC(&srv->counters.srv_aborts);
>                                        ^
>include/haproxy/atomic.h:439:44: note: expanded from macro '_HA_ATOMIC_INC'
>#define _HA_ATOMIC_INC(val)           do { __atomic_add_fetch(val, 1, __ATOMIC_RELAXED); } while (0)
>                                           ^
>src/stream.c:2079:5: warning: large atomic operation may incur significant performance penalty [-Watomic-alignment]
>                                _HA_ATOMIC_INC(&s->be->be_counters.srv_aborts);
>                                ^
>include/haproxy/atomic.h:439:44: note: expanded from macro '_HA_ATOMIC_INC'
>#define _HA_ATOMIC_INC(val)           do { __atomic_add_fetch(val, 1, __ATOMIC_RELAXED); } while (0)
>                                           ^
>src/stream.c:2080:5: warning: large atomic operation may incur significant performance penalty [-Watomic-alignment]
>                                _HA_ATOMIC_INC(&sess->fe->fe_counters.srv_aborts);
>                                ^
>include/haproxy/atomic.h:439:44: note: expanded from macro '_HA_ATOMIC_INC'
>#define _HA_ATOMIC_INC(val)           do { __atomic_add_fetch(val, 1, __ATOMIC_RELAXED); } while (0)
>                                           ^
>src/stream.c:2082:6: warning: large atomic operation may incur significant performance penalty [-Watomic-alignment]
>                                        _HA_ATOMIC_INC(&sess->listener->counters->srv_aborts);
>                                        ^
>include/haproxy/atomic.h:439:44: note: expanded from macro '_HA_ATOMIC_INC'
>#define _HA_ATOMIC_INC(val)           do { __atomic_add_fetch(val, 1, __ATOMIC_RELAXED); } while (0)
>                                           ^
>src/stream.c:2084:6: warning: large atomic operation may incur significant performance penalty [-Watomic-alignment]
>                                        _HA_ATOMIC_INC(&srv->counters.srv_aborts);
>                                        ^
>include/haproxy/atomic.h:439:44: note: expanded from macro '_HA_ATOMIC_INC'
>#define _HA_ATOMIC_INC(val)           do { __atomic_add_fetch(val, 1, __ATOMIC_RELAXED); } while (0)
>                                           ^
>src/stream.c:2088:5: warning: large atomic operation may incur significant performance penalty [-Watomic-alignment]
>                                _HA_ATOMIC_INC(&s->be->be_counters.cli_aborts);
>                                ^
>include/haproxy/atomic.h:439:44: note: expanded from macro '_HA_ATOMIC_INC'
>#define _HA_ATOMIC_INC(val)           do { __atomic_add_fetch(val, 1, __ATOMIC_RELAXED); } while (0)
>                                           ^
>src/stream.c:2089:5: warning: large atomic operation may incur significant performance penalty [-Watomic-alignment]
>                                _HA_ATOMIC_INC(&sess->fe->fe_counters.cli_aborts);
>                                ^
>include/haproxy/atomic.h:439:44: note: expanded from macro '_HA_ATOMIC_INC'
>#define _HA_ATOMIC_INC(val)           do { __atomic_add_fetch(val, 1, __ATOMIC_RELAXED); } while (0)
>                                           ^
>src/stream.c:2091:6: warning: large atomic operation may incur significant performance penalty [-Watomic-alignment]
>                                        _HA_ATOMIC_INC(&sess->listener->counters->cli_aborts);
>                                        ^
>include/haproxy/atomic.h:439:44: note: expanded from macro '_HA_ATOMIC_INC'
>#define _HA_ATOMIC_INC(val)           do { __atomic_add_fetch(val, 1, __ATOMIC_RELAXED); } while (0)
>                                           ^
>src/stream.c:2093:6: warning: large atomic operation may incur significant performance penalty [-Watomic-alignment]
>                                        _HA_ATOMIC_INC(&srv->counters.cli_aborts);
>                                        ^
>include/haproxy/atomic.h:439:44: note: expanded from macro '_HA_ATOMIC_INC'
>#define _HA_ATOMIC_INC(val)           do { __atomic_add_fetch(val, 1, __ATOMIC_RELAXED); } while (0)
>                                           ^
>src/stream.c:2097:5: warning: large atomic operation may incur significant performance penalty [-Watomic-alignment]
>                                _HA_ATOMIC_INC(&s->be->be_counters.cli_aborts);
>                                ^
>include/haproxy/atomic.h:439:44: note: expanded from macro '_HA_ATOMIC_INC'
>#define _HA_ATOMIC_INC(val)           do { __atomic_add_fetch(val, 1, __ATOMIC_RELAXED); } while (0)
>                                           ^
>src/stream.c:2098:5: warning: large atomic operation may incur significant performance penalty [-Watomic-alignment]
>                                _HA_ATOMIC_INC(&sess->fe->fe_counters.cli_aborts);
>                                ^
>include/haproxy/atomic.h:439:44: note: expanded from macro '_HA_ATOMIC_INC'
>#define _HA_ATOMIC_INC(val)           do { __atomic_add_fetch(val, 1, __ATOMIC_RELAXED); } while (0)
>                                           ^
>src/stream.c:2100:6: warning: large atomic operation may incur significant performance penalty [-Watomic-alignment]
>                                        _HA_ATOMIC_INC(&sess->listener->counters->cli_aborts);
>                                        ^
>include/haproxy/atomic.h:439:44: note: expanded from macro '_HA_ATOMIC_INC'
>#define _HA_ATOMIC_INC(val)           do { __atomic_add_fetch(val, 1, __ATOMIC_RELAXED); } while (0)
>                                           ^
>src/stream.c:2102:6: warning: large atomic operation may incur significant performance penalty [-Watomic-alignment]
>                                        _HA_ATOMIC_INC(&srv->counters.cli_aborts);
>                                        ^
>include/haproxy/atomic.h:439:44: note: expanded from macro '_HA_ATOMIC_INC'
>#define _HA_ATOMIC_INC(val)           do { __atomic_add_fetch(val, 1, __ATOMIC_RELAXED); } while (0)
>                                           ^
>src/stream.c:2524:5: warning: large atomic operation may incur significant performance penalty [-Watomic-alignment]
>                                _HA_ATOMIC_INC(&sess->fe->fe_counters.p.http.rsp[n]);
>                                ^
>include/haproxy/atomic.h:439:44: note: expanded from macro '_HA_ATOMIC_INC'
>#define _HA_ATOMIC_INC(val)           do { __atomic_add_fetch(val, 1, __ATOMIC_RELAXED); } while (0)
>                                           ^
>src/stream.c:2528:5: warning: large atomic operation may incur significant performance penalty [-Watomic-alignment]
>                                _HA_ATOMIC_INC(&s->be->be_counters.p.http.rsp[n]);
>                                ^
>include/haproxy/atomic.h:439:44: note: expanded from macro '_HA_ATOMIC_INC'
>#define _HA_ATOMIC_INC(val)           do { __atomic_add_fetch(val, 1, __ATOMIC_RELAXED); } while (0)
>                                           ^
>src/stream.c:2529:5: warning: large atomic operation may incur significant performance penalty [-Watomic-alignment]
>                                _HA_ATOMIC_INC(&s->be->be_counters.p.http.cum_req);
>                                ^
>include/haproxy/atomic.h:439:44: note: expanded from macro '_HA_ATOMIC_INC'
>#define _HA_ATOMIC_INC(val)           do { __atomic_add_fetch(val, 1, __ATOMIC_RELAXED); } while (0)
>                                           ^
>src/stream.c:975:4: warning: large atomic operation may incur significant performance penalty [-Watomic-alignment]
>                        _HA_ATOMIC_INC(&strm_fe(s)->fe_counters.failed_req);
>                        ^
>include/haproxy/atomic.h:439:44: note: expanded from macro '_HA_ATOMIC_INC'
>#define _HA_ATOMIC_INC(val)           do { __atomic_add_fetch(val, 1, __ATOMIC_RELAXED); } while (0)
>                                           ^
>src/stream.c:977:5: warning: large atomic operation may incur significant performance penalty [-Watomic-alignment]
>                                _HA_ATOMIC_INC(&strm_li(s)->counters->failed_req);
>                                ^
>include/haproxy/atomic.h:439:44: note: expanded from macro '_HA_ATOMIC_INC'
>#define _HA_ATOMIC_INC(val)           do { __atomic_add_fetch(val, 1, __ATOMIC_RELAXED); } while (0)
>                                           ^
>56 warnings generated.
>  CC      src/tcpcheck.o
>  CC      src/stats.o
>  CC      src/flt_spoe.o
>src/flt_spoe.c:2623:2: warning: large atomic operation may incur significant performance penalty [-Watomic-alignment]
>        _HA_ATOMIC_INC(&agent->counters.nb_processed);
>        ^
>include/haproxy/atomic.h:439:44: note: expanded from macro '_HA_ATOMIC_INC'
>#define _HA_ATOMIC_INC(val)           do { __atomic_add_fetch(val, 1, __ATOMIC_RELAXED); } while (0)
>                                           ^
>src/flt_spoe.c:2757:3: warning: large atomic operation may incur significant performance penalty [-Watomic-alignment]
>                _HA_ATOMIC_INC(&agent->counters.nb_errors);
>                ^
>include/haproxy/atomic.h:439:44: note: expanded from macro '_HA_ATOMIC_INC'
>#define _HA_ATOMIC_INC(val)           do { __atomic_add_fetch(val, 1, __ATOMIC_RELAXED); } while (0)
>                                           ^
>2 warnings generated.
>  CC      src/server.o
>  CC      src/tools.o
>  CC      src/sample.o
>  CC      src/log.o
>In file included from src/log.c:37:
>include/haproxy/proxy.h:154:2: warning: large atomic operation may incur significant performance penalty [-Watomic-alignment]
>        _HA_ATOMIC_INC(&fe->fe_counters.p.http.cum_req);
>        ^
>include/haproxy/atomic.h:439:44: note: expanded from macro '_HA_ATOMIC_INC'
>#define _HA_ATOMIC_INC(val)           do { __atomic_add_fetch(val, 1, __ATOMIC_RELAXED); } while (0)
>                                           ^
>In file included from src/log.c:37:
>include/haproxy/proxy.h:156:3: warning: large atomic operation may incur significant performance penalty [-Watomic-alignment]
>                _HA_ATOMIC_INC(&l->counters->p.http.cum_req);
>                ^
>include/haproxy/atomic.h:439:44: note: expanded from macro '_HA_ATOMIC_INC'
>#define _HA_ATOMIC_INC(val)           do { __atomic_add_fetch(val, 1, __ATOMIC_RELAXED); } while (0)
>                                           ^
>src/log.c:3861:3: warning: large atomic operation may incur significant performance penalty [-Watomic-alignment]
>                _HA_ATOMIC_INC(&l->counters->failed_req);
>                ^
>include/haproxy/atomic.h:439:44: note: expanded from macro '_HA_ATOMIC_INC'
>#define _HA_ATOMIC_INC(val)           do { __atomic_add_fetch(val, 1, __ATOMIC_RELAXED); } while (0)
>                                           ^
>src/log.c:3862:2: warning: large atomic operation may incur significant performance penalty [-Watomic-alignment]
>        _HA_ATOMIC_INC(&frontend->fe_counters.failed_req);
>        ^
>include/haproxy/atomic.h:439:44: note: expanded from macro '_HA_ATOMIC_INC'
>#define _HA_ATOMIC_INC(val)           do { __atomic_add_fetch(val, 1, __ATOMIC_RELAXED); } while (0)
>                                           ^
>src/log.c:3868:3: warning: large atomic operation may incur significant performance penalty [-Watomic-alignment]
>                _HA_ATOMIC_INC(&l->counters->cli_aborts);
>                ^
>include/haproxy/atomic.h:439:44: note: expanded from macro '_HA_ATOMIC_INC'
>#define _HA_ATOMIC_INC(val)           do { __atomic_add_fetch(val, 1, __ATOMIC_RELAXED); } while (0)
>                                           ^
>src/log.c:3869:2: warning: large atomic operation may incur significant performance penalty [-Watomic-alignment]
>        _HA_ATOMIC_INC(&frontend->fe_counters.cli_aborts);
>        ^
>include/haproxy/atomic.h:439:44: note: expanded from macro '_HA_ATOMIC_INC'
>#define _HA_ATOMIC_INC(val)           do { __atomic_add_fetch(val, 1, __ATOMIC_RELAXED); } while (0)
>                                           ^
>6 warnings generated.
>  CC      src/backend.o
>src/backend.c:785:4: warning: large atomic operation may incur significant performance penalty [-Watomic-alignment]
>                        _HA_ATOMIC_INC(&s->be->be_counters.cum_lbconn);
>                        ^
>include/haproxy/atomic.h:439:44: note: expanded from macro '_HA_ATOMIC_INC'
>#define _HA_ATOMIC_INC(val)           do { __atomic_add_fetch(val, 1, __ATOMIC_RELAXED); } while (0)
>                                           ^
>src/backend.c:786:4: warning: large atomic operation may incur significant performance penalty [-Watomic-alignment]
>                        _HA_ATOMIC_INC(&srv->counters.cum_lbconn);
>                        ^
>include/haproxy/atomic.h:439:44: note: expanded from macro '_HA_ATOMIC_INC'
>#define _HA_ATOMIC_INC(val)           do { __atomic_add_fetch(val, 1, __ATOMIC_RELAXED); } while (0)
>                                           ^
>src/backend.c:966:5: warning: large atomic operation may incur significant performance penalty [-Watomic-alignment]
>                                _HA_ATOMIC_INC(&prev_srv->counters.redispatches);
>                                ^
>include/haproxy/atomic.h:439:44: note: expanded from macro '_HA_ATOMIC_INC'
>#define _HA_ATOMIC_INC(val)           do { __atomic_add_fetch(val, 1, __ATOMIC_RELAXED); } while (0)
>                                           ^
>src/backend.c:967:5: warning: large atomic operation may incur significant performance penalty [-Watomic-alignment]
>                                _HA_ATOMIC_INC(&s->be->be_counters.redispatches);
>                                ^
>include/haproxy/atomic.h:439:44: note: expanded from macro '_HA_ATOMIC_INC'
>#define _HA_ATOMIC_INC(val)           do { __atomic_add_fetch(val, 1, __ATOMIC_RELAXED); } while (0)
>                                           ^
>src/backend.c:969:5: warning: large atomic operation may incur significant performance penalty [-Watomic-alignment]
>                                _HA_ATOMIC_INC(&prev_srv->counters.retries);
>                                ^
>include/haproxy/atomic.h:439:44: note: expanded from macro '_HA_ATOMIC_INC'
>#define _HA_ATOMIC_INC(val)           do { __atomic_add_fetch(val, 1, __ATOMIC_RELAXED); } while (0)
>                                           ^
>src/backend.c:970:5: warning: large atomic operation may incur significant performance penalty [-Watomic-alignment]
>                                _HA_ATOMIC_INC(&s->be->be_counters.retries);
>                                ^
>include/haproxy/atomic.h:439:44: note: expanded from macro '_HA_ATOMIC_INC'
>#define _HA_ATOMIC_INC(val)           do { __atomic_add_fetch(val, 1, __ATOMIC_RELAXED); } while (0)
>                                           ^
>src/backend.c:1659:3: warning: large atomic operation may incur significant performance penalty [-Watomic-alignment]
>                _HA_ATOMIC_INC(&s->be->be_counters.reuse);
>                ^
>include/haproxy/atomic.h:439:44: note: expanded from macro '_HA_ATOMIC_INC'
>#define _HA_ATOMIC_INC(val)           do { __atomic_add_fetch(val, 1, __ATOMIC_RELAXED); } while (0)
>                                           ^
>src/backend.c:1661:4: warning: large atomic operation may incur significant performance penalty [-Watomic-alignment]
>                        _HA_ATOMIC_INC(&srv->counters.reuse);
>                        ^
>include/haproxy/atomic.h:439:44: note: expanded from macro '_HA_ATOMIC_INC'
>#define _HA_ATOMIC_INC(val)           do { __atomic_add_fetch(val, 1, __ATOMIC_RELAXED); } while (0)
>                                           ^
>src/backend.c:1663:3: warning: large atomic operation may incur significant performance penalty [-Watomic-alignment]
>                _HA_ATOMIC_INC(&s->be->be_counters.connect);
>                ^
>include/haproxy/atomic.h:439:44: note: expanded from macro '_HA_ATOMIC_INC'
>#define _HA_ATOMIC_INC(val)           do { __atomic_add_fetch(val, 1, __ATOMIC_RELAXED); } while (0)
>                                           ^
>src/backend.c:1665:4: warning: large atomic operation may incur significant performance penalty [-Watomic-alignment]
>                        _HA_ATOMIC_INC(&srv->counters.connect);
>                        ^
>include/haproxy/atomic.h:439:44: note: expanded from macro '_HA_ATOMIC_INC'
>#define _HA_ATOMIC_INC(val)           do { __atomic_add_fetch(val, 1, __ATOMIC_RELAXED); } while (0)
>                                           ^
>src/backend.c:1842:3: warning: large atomic operation may incur significant performance penalty [-Watomic-alignment]
>                _HA_ATOMIC_INC(&srv->counters.failed_conns);
>                ^
>include/haproxy/atomic.h:439:44: note: expanded from macro '_HA_ATOMIC_INC'
>#define _HA_ATOMIC_INC(val)           do { __atomic_add_fetch(val, 1, __ATOMIC_RELAXED); } while (0)
>                                           ^
>src/backend.c:1843:3: warning: large atomic operation may incur significant performance penalty [-Watomic-alignment]
>                _HA_ATOMIC_INC(&s->be->be_counters.failed_conns);
>                ^
>include/haproxy/atomic.h:439:44: note: expanded from macro '_HA_ATOMIC_INC'
>#define _HA_ATOMIC_INC(val)           do { __atomic_add_fetch(val, 1, __ATOMIC_RELAXED); } while (0)
>                                           ^
>src/backend.c:1852:3: warning: large atomic operation may incur significant performance penalty [-Watomic-alignment]
>                _HA_ATOMIC_INC(&s->be->be_counters.failed_conns);
>                ^
>include/haproxy/atomic.h:439:44: note: expanded from macro '_HA_ATOMIC_INC'
>#define _HA_ATOMIC_INC(val)           do { __atomic_add_fetch(val, 1, __ATOMIC_RELAXED); } while (0)
>                                           ^
>src/backend.c:1872:4: warning: large atomic operation may incur significant performance penalty [-Watomic-alignment]
>                        _HA_ATOMIC_INC(&srv->counters.failed_conns);
>                        ^
>include/haproxy/atomic.h:439:44: note: expanded from macro '_HA_ATOMIC_INC'
>#define _HA_ATOMIC_INC(val)           do { __atomic_add_fetch(val, 1, __ATOMIC_RELAXED); } while (0)
>                                           ^
>src/backend.c:1873:3: warning: large atomic operation may incur significant performance penalty [-Watomic-alignment]
>                _HA_ATOMIC_INC(&s->be->be_counters.failed_conns);
>                ^
>include/haproxy/atomic.h:439:44: note: expanded from macro '_HA_ATOMIC_INC'
>#define _HA_ATOMIC_INC(val)           do { __atomic_add_fetch(val, 1, __ATOMIC_RELAXED); } while (0)
>                                           ^
>src/backend.c:1947:5: warning: large atomic operation may incur significant performance penalty [-Watomic-alignment]
>                                _HA_ATOMIC_INC(&srv->counters.failed_conns);
>                                ^
>include/haproxy/atomic.h:439:44: note: expanded from macro '_HA_ATOMIC_INC'
>#define _HA_ATOMIC_INC(val)           do { __atomic_add_fetch(val, 1, __ATOMIC_RELAXED); } while (0)
>                                           ^
>src/backend.c:1948:4: warning: large atomic operation may incur significant performance penalty [-Watomic-alignment]
>                        _HA_ATOMIC_INC(&s->be->be_counters.failed_conns);
>                        ^
>include/haproxy/atomic.h:439:44: note: expanded from macro '_HA_ATOMIC_INC'
>#define _HA_ATOMIC_INC(val)           do { __atomic_add_fetch(val, 1, __ATOMIC_RELAXED); } while (0)
>                                           ^
>src/backend.c:2014:5: warning: large atomic operation may incur significant performance penalty [-Watomic-alignment]
>                                _HA_ATOMIC_INC(&srv->counters.failed_conns);
>                                ^
>include/haproxy/atomic.h:439:44: note: expanded from macro '_HA_ATOMIC_INC'
>#define _HA_ATOMIC_INC(val)           do { __atomic_add_fetch(val, 1, __ATOMIC_RELAXED); } while (0)
>                                           ^
>src/backend.c:2015:4: warning: large atomic operation may incur significant performance penalty [-Watomic-alignment]
>                        _HA_ATOMIC_INC(&s->be->be_counters.failed_conns);
>                        ^
>include/haproxy/atomic.h:439:44: note: expanded from macro '_HA_ATOMIC_INC'
>#define _HA_ATOMIC_INC(val)           do { __atomic_add_fetch(val, 1, __ATOMIC_RELAXED); } while (0)
>                                           ^
>src/backend.c:2277:4: warning: large atomic operation may incur significant performance penalty [-Watomic-alignment]
>                        _HA_ATOMIC_INC(&objt_server(s->target)->counters.failed_conns);
>                        ^
>include/haproxy/atomic.h:439:44: note: expanded from macro '_HA_ATOMIC_INC'
>#define _HA_ATOMIC_INC(val)           do { __atomic_add_fetch(val, 1, __ATOMIC_RELAXED); } while (0)
>                                           ^
>src/backend.c:2278:3: warning: large atomic operation may incur significant performance penalty [-Watomic-alignment]
>                _HA_ATOMIC_INC(&s->be->be_counters.failed_conns);
>                ^
>include/haproxy/atomic.h:439:44: note: expanded from macro '_HA_ATOMIC_INC'
>#define _HA_ATOMIC_INC(val)           do { __atomic_add_fetch(val, 1, __ATOMIC_RELAXED); } while (0)
>                                           ^
>In file included from src/backend.c:49:
>include/haproxy/server.h:166:2: warning: large atomic operation may incur significant performance penalty [-Watomic-alignment]
>        _HA_ATOMIC_INC(&s->counters.cum_sess);
>        ^
>include/haproxy/atomic.h:439:44: note: expanded from macro '_HA_ATOMIC_INC'
>#define _HA_ATOMIC_INC(val)           do { __atomic_add_fetch(val, 1, __ATOMIC_RELAXED); } while (0)
>                                           ^
>In file included from src/backend.c:26:
>In file included from include/haproxy/channel.h:30:
>include/haproxy/stream.h:348:4: warning: large atomic operation may incur significant performance penalty [-Watomic-alignment]
>                        _HA_ATOMIC_INC(&__objt_server(s->target)->counters.retries);
>                        ^
>include/haproxy/atomic.h:439:44: note: expanded from macro '_HA_ATOMIC_INC'
>#define _HA_ATOMIC_INC(val)           do { __atomic_add_fetch(val, 1, __ATOMIC_RELAXED); } while (0)
>                                           ^
>In file included from src/backend.c:26:
>In file included from include/haproxy/channel.h:30:
>include/haproxy/stream.h:349:3: warning: large atomic operation may incur significant performance penalty [-Watomic-alignment]
>                _HA_ATOMIC_INC(&s->be->be_counters.retries);
>                ^
>include/haproxy/atomic.h:439:44: note: expanded from macro '_HA_ATOMIC_INC'
>#define _HA_ATOMIC_INC(val)           do { __atomic_add_fetch(val, 1, __ATOMIC_RELAXED); } while (0)
>                                           ^
>24 warnings generated.
>  CC      src/stick_table.o
>src/stick_table.c:3697:12: warning: result of comparison 'unsigned long' > 4294967295 is always false [-Wtautological-type-limit-compare]
>                            val > 0xffffffff)
>                            ~~~ ^ ~~~~~~~~~~
>1 warning generated.
>  CC      src/cfgparse.o
>  CC      src/peers.o
>  CC      src/cli.o
>  CC      src/pattern.o
>  CC      src/resolvers.o
>  CC      src/proxy.o
>In file included from src/proxy.c:42:
>include/haproxy/proxy.h:146:2: warning: large atomic operation may incur significant performance penalty [-Watomic-alignment]
>        _HA_ATOMIC_INC(&be->be_counters.cum_conn);
>        ^
>include/haproxy/atomic.h:439:44: note: expanded from macro '_HA_ATOMIC_INC'
>#define _HA_ATOMIC_INC(val)           do { __atomic_add_fetch(val, 1, __ATOMIC_RELAXED); } while (0)
>                                           ^
>1 warning generated.
>  CC      src/http_htx.o
>  CC      src/check.o
>src/check.c:497:4: warning: large atomic operation may incur significant performance penalty [-Watomic-alignment]
>                        _HA_ATOMIC_INC(&s->counters.failed_checks);
>                        ^
>include/haproxy/atomic.h:439:44: note: expanded from macro '_HA_ATOMIC_INC'
>#define _HA_ATOMIC_INC(val)           do { __atomic_add_fetch(val, 1, __ATOMIC_RELAXED); } while (0)
>                                           ^
>src/check.c:717:2: warning: large atomic operation may incur significant performance penalty [-Watomic-alignment]
>        _HA_ATOMIC_INC(&s->counters.failed_hana);
>        ^
>include/haproxy/atomic.h:439:44: note: expanded from macro '_HA_ATOMIC_INC'
>#define _HA_ATOMIC_INC(val)           do { __atomic_add_fetch(val, 1, __ATOMIC_RELAXED); } while (0)
>                                           ^
>2 warnings generated.
>  CC      src/cache.o
>src/cache.c:1772:3: warning: large atomic operation may incur significant performance penalty [-Watomic-alignment]
>                _HA_ATOMIC_INC(&px->fe_counters.p.http.cache_lookups);
>                ^
>include/haproxy/atomic.h:439:44: note: expanded from macro '_HA_ATOMIC_INC'
>#define _HA_ATOMIC_INC(val)           do { __atomic_add_fetch(val, 1, __ATOMIC_RELAXED); } while (0)
>                                           ^
>src/cache.c:1774:3: warning: large atomic operation may incur significant performance penalty [-Watomic-alignment]
>                _HA_ATOMIC_INC(&px->be_counters.p.http.cache_lookups);
>                ^
>include/haproxy/atomic.h:439:44: note: expanded from macro '_HA_ATOMIC_INC'
>#define _HA_ATOMIC_INC(val)           do { __atomic_add_fetch(val, 1, __ATOMIC_RELAXED); } while (0)
>                                           ^
>src/cache.c:1826:5: warning: large atomic operation may incur significant performance penalty [-Watomic-alignment]
>                                _HA_ATOMIC_INC(&px->fe_counters.p.http.cache_hits);
>                                ^
>include/haproxy/atomic.h:439:44: note: expanded from macro '_HA_ATOMIC_INC'
>#define _HA_ATOMIC_INC(val)           do { __atomic_add_fetch(val, 1, __ATOMIC_RELAXED); } while (0)
>                                           ^
>src/cache.c:1828:5: warning: large atomic operation may incur significant performance penalty [-Watomic-alignment]
>                                _HA_ATOMIC_INC(&px->be_counters.p.http.cache_hits);
>                                ^
>include/haproxy/atomic.h:439:44: note: expanded from macro '_HA_ATOMIC_INC'
>#define _HA_ATOMIC_INC(val)           do { __atomic_add_fetch(val, 1, __ATOMIC_RELAXED); } while (0)
>                                           ^
>4 warnings generated.
>  CC      src/cfgparse-listen.o
>  CC      src/haproxy.o
>  CC      src/http_act.o
>src/http_act.c:1568:2: warning: large atomic operation may incur significant performance penalty [-Watomic-alignment]
>        _HA_ATOMIC_INC(&sess->fe->fe_counters.failed_rewrites);
>        ^
>include/haproxy/atomic.h:439:44: note: expanded from macro '_HA_ATOMIC_INC'
>#define _HA_ATOMIC_INC(val)           do { __atomic_add_fetch(val, 1, __ATOMIC_RELAXED); } while (0)
>                                           ^
>src/http_act.c:1570:3: warning: large atomic operation may incur significant performance penalty [-Watomic-alignment]
>                _HA_ATOMIC_INC(&s->be->be_counters.failed_rewrites);
>                ^
>include/haproxy/atomic.h:439:44: note: expanded from macro '_HA_ATOMIC_INC'
>#define _HA_ATOMIC_INC(val)           do { __atomic_add_fetch(val, 1, __ATOMIC_RELAXED); } while (0)
>                                           ^
>src/http_act.c:1572:3: warning: large atomic operation may incur significant performance penalty [-Watomic-alignment]
>                _HA_ATOMIC_INC(&sess->listener->counters->failed_rewrites);
>                ^
>include/haproxy/atomic.h:439:44: note: expanded from macro '_HA_ATOMIC_INC'
>#define _HA_ATOMIC_INC(val)           do { __atomic_add_fetch(val, 1, __ATOMIC_RELAXED); } while (0)
>                                           ^
>src/http_act.c:1574:3: warning: large atomic operation may incur significant performance penalty [-Watomic-alignment]
>                _HA_ATOMIC_INC(&__objt_server(s->target)->counters.failed_rewrites);
>                ^
>include/haproxy/atomic.h:439:44: note: expanded from macro '_HA_ATOMIC_INC'
>#define _HA_ATOMIC_INC(val)           do { __atomic_add_fetch(val, 1, __ATOMIC_RELAXED); } while (0)
>                                           ^
>src/http_act.c:1279:3: warning: large atomic operation may incur significant performance penalty [-Watomic-alignment]
>                _HA_ATOMIC_INC(&s->sess->fe->fe_counters.intercepted_req);
>                ^
>include/haproxy/atomic.h:439:44: note: expanded from macro '_HA_ATOMIC_INC'
>#define _HA_ATOMIC_INC(val)           do { __atomic_add_fetch(val, 1, __ATOMIC_RELAXED); } while (0)
>                                           ^
>src/http_act.c:387:2: warning: large atomic operation may incur significant performance penalty [-Watomic-alignment]
>        _HA_ATOMIC_ADD(&sess->fe->fe_counters.failed_rewrites, 1);
>        ^
>include/haproxy/atomic.h:437:44: note: expanded from macro '_HA_ATOMIC_ADD'
>#define _HA_ATOMIC_ADD(val, i)        do { __atomic_add_fetch(val, i, __ATOMIC_RELAXED); } while (0)
>                                           ^
>src/http_act.c:389:3: warning: large atomic operation may incur significant performance penalty [-Watomic-alignment]
>                _HA_ATOMIC_ADD(&s->be->be_counters.failed_rewrites, 1);
>                ^
>include/haproxy/atomic.h:437:44: note: expanded from macro '_HA_ATOMIC_ADD'
>#define _HA_ATOMIC_ADD(val, i)        do { __atomic_add_fetch(val, i, __ATOMIC_RELAXED); } while (0)
>                                           ^
>src/http_act.c:391:3: warning: large atomic operation may incur significant performance penalty [-Watomic-alignment]
>                _HA_ATOMIC_ADD(&sess->listener->counters->failed_rewrites, 1);
>                ^
>include/haproxy/atomic.h:437:44: note: expanded from macro '_HA_ATOMIC_ADD'
>#define _HA_ATOMIC_ADD(val, i)        do { __atomic_add_fetch(val, i, __ATOMIC_RELAXED); } while (0)
>                                           ^
>src/http_act.c:393:3: warning: large atomic operation may incur significant performance penalty [-Watomic-alignment]
>                _HA_ATOMIC_ADD(&__objt_server(s->target)->counters.failed_rewrites, 1);
>                ^
>include/haproxy/atomic.h:437:44: note: expanded from macro '_HA_ATOMIC_ADD'
>#define _HA_ATOMIC_ADD(val, i)        do { __atomic_add_fetch(val, i, __ATOMIC_RELAXED); } while (0)
>                                           ^
>src/http_act.c:713:2: warning: large atomic operation may incur significant performance penalty [-Watomic-alignment]
>        _HA_ATOMIC_INC(&s->be->be_counters.denied_req);
>        ^
>include/haproxy/atomic.h:439:44: note: expanded from macro '_HA_ATOMIC_INC'
>#define _HA_ATOMIC_INC(val)           do { __atomic_add_fetch(val, 1, __ATOMIC_RELAXED); } while (0)
>                                           ^
>src/http_act.c:714:2: warning: large atomic operation may incur significant performance penalty [-Watomic-alignment]
>        _HA_ATOMIC_INC(&sess->fe->fe_counters.denied_req);
>        ^
>include/haproxy/atomic.h:439:44: note: expanded from macro '_HA_ATOMIC_INC'
>#define _HA_ATOMIC_INC(val)           do { __atomic_add_fetch(val, 1, __ATOMIC_RELAXED); } while (0)
>                                           ^
>src/http_act.c:716:3: warning: large atomic operation may incur significant performance penalty [-Watomic-alignment]
>                _HA_ATOMIC_INC(&sess->listener->counters->denied_req);
>                ^
>include/haproxy/atomic.h:439:44: note: expanded from macro '_HA_ATOMIC_INC'
>#define _HA_ATOMIC_INC(val)           do { __atomic_add_fetch(val, 1, __ATOMIC_RELAXED); } while (0)
>                                           ^
>src/http_act.c:1687:2: warning: large atomic operation may incur significant performance penalty [-Watomic-alignment]
>        _HA_ATOMIC_INC(&sess->fe->fe_counters.failed_rewrites);
>        ^
>include/haproxy/atomic.h:439:44: note: expanded from macro '_HA_ATOMIC_INC'
>#define _HA_ATOMIC_INC(val)           do { __atomic_add_fetch(val, 1, __ATOMIC_RELAXED); } while (0)
>                                           ^
>src/http_act.c:1689:3: warning: large atomic operation may incur significant performance penalty [-Watomic-alignment]
>                _HA_ATOMIC_INC(&s->be->be_counters.failed_rewrites);
>                ^
>include/haproxy/atomic.h:439:44: note: expanded from macro '_HA_ATOMIC_INC'
>#define _HA_ATOMIC_INC(val)           do { __atomic_add_fetch(val, 1, __ATOMIC_RELAXED); } while (0)
>                                           ^
>src/http_act.c:1691:3: warning: large atomic operation may incur significant performance penalty [-Watomic-alignment]
>                _HA_ATOMIC_INC(&sess->listener->counters->failed_rewrites);
>                ^
>include/haproxy/atomic.h:439:44: note: expanded from macro '_HA_ATOMIC_INC'
>#define _HA_ATOMIC_INC(val)           do { __atomic_add_fetch(val, 1, __ATOMIC_RELAXED); } while (0)
>                                           ^
>src/http_act.c:1693:3: warning: large atomic operation may incur significant performance penalty [-Watomic-alignment]
>                _HA_ATOMIC_INC(&__objt_server(s->target)->counters.failed_rewrites);
>                ^
>include/haproxy/atomic.h:439:44: note: expanded from macro '_HA_ATOMIC_INC'
>#define _HA_ATOMIC_INC(val)           do { __atomic_add_fetch(val, 1, __ATOMIC_RELAXED); } while (0)
>                                           ^
>src/http_act.c:556:2: warning: large atomic operation may incur significant performance penalty [-Watomic-alignment]
>        _HA_ATOMIC_INC(&sess->fe->fe_counters.failed_rewrites);
>        ^
>include/haproxy/atomic.h:439:44: note: expanded from macro '_HA_ATOMIC_INC'
>#define _HA_ATOMIC_INC(val)           do { __atomic_add_fetch(val, 1, __ATOMIC_RELAXED); } while (0)
>                                           ^
>src/http_act.c:558:3: warning: large atomic operation may incur significant performance penalty [-Watomic-alignment]
>                _HA_ATOMIC_INC(&s->be->be_counters.failed_rewrites);
>                ^
>include/haproxy/atomic.h:439:44: note: expanded from macro '_HA_ATOMIC_INC'
>#define _HA_ATOMIC_INC(val)           do { __atomic_add_fetch(val, 1, __ATOMIC_RELAXED); } while (0)
>                                           ^
>src/http_act.c:560:3: warning: large atomic operation may incur significant performance penalty [-Watomic-alignment]
>                _HA_ATOMIC_INC(&sess->listener->counters->failed_rewrites);
>                ^
>include/haproxy/atomic.h:439:44: note: expanded from macro '_HA_ATOMIC_INC'
>#define _HA_ATOMIC_INC(val)           do { __atomic_add_fetch(val, 1, __ATOMIC_RELAXED); } while (0)
>                                           ^
>src/http_act.c:562:3: warning: large atomic operation may incur significant performance penalty [-Watomic-alignment]
>                _HA_ATOMIC_INC(&__objt_server(s->target)->counters.failed_rewrites);
>                ^
>include/haproxy/atomic.h:439:44: note: expanded from macro '_HA_ATOMIC_INC'
>#define _HA_ATOMIC_INC(val)           do { __atomic_add_fetch(val, 1, __ATOMIC_RELAXED); } while (0)
>                                           ^
>src/http_act.c:2373:4: warning: large atomic operation may incur significant performance penalty [-Watomic-alignment]
>                        _HA_ATOMIC_INC(&s->sess->fe->fe_counters.intercepted_req);
>                        ^
>include/haproxy/atomic.h:439:44: note: expanded from macro '_HA_ATOMIC_INC'
>#define _HA_ATOMIC_INC(val)           do { __atomic_add_fetch(val, 1, __ATOMIC_RELAXED); } while (0)
>                                           ^
>src/http_act.c:125:2: warning: large atomic operation may incur significant performance penalty [-Watomic-alignment]
>        _HA_ATOMIC_INC(&sess->fe->fe_counters.failed_rewrites);
>        ^
>include/haproxy/atomic.h:439:44: note: expanded from macro '_HA_ATOMIC_INC'
>#define _HA_ATOMIC_INC(val)           do { __atomic_add_fetch(val, 1, __ATOMIC_RELAXED); } while (0)
>                                           ^
>src/http_act.c:127:3: warning: large atomic operation may incur significant performance penalty [-Watomic-alignment]
>                _HA_ATOMIC_INC(&s->be->be_counters.failed_rewrites);
>                ^
>include/haproxy/atomic.h:439:44: note: expanded from macro '_HA_ATOMIC_INC'
>#define _HA_ATOMIC_INC(val)           do { __atomic_add_fetch(val, 1, __ATOMIC_RELAXED); } while (0)
>                                           ^
>src/http_act.c:129:3: warning: large atomic operation may incur significant performance penalty [-Watomic-alignment]
>                _HA_ATOMIC_INC(&sess->listener->counters->failed_rewrites);
>                ^
>include/haproxy/atomic.h:439:44: note: expanded from macro '_HA_ATOMIC_INC'
>#define _HA_ATOMIC_INC(val)           do { __atomic_add_fetch(val, 1, __ATOMIC_RELAXED); } while (0)
>                                           ^
>src/http_act.c:131:3: warning: large atomic operation may incur significant performance penalty [-Watomic-alignment]
>                _HA_ATOMIC_INC(&__objt_server(s->target)->counters.failed_rewrites);
>                ^
>include/haproxy/atomic.h:439:44: note: expanded from macro '_HA_ATOMIC_INC'
>#define _HA_ATOMIC_INC(val)           do { __atomic_add_fetch(val, 1, __ATOMIC_RELAXED); } while (0)
>                                           ^
>src/http_act.c:636:3: warning: large atomic operation may incur significant performance penalty [-Watomic-alignment]
>                _HA_ATOMIC_INC(&sess->fe->fe_counters.failed_rewrites);
>                ^
>include/haproxy/atomic.h:439:44: note: expanded from macro '_HA_ATOMIC_INC'
>#define _HA_ATOMIC_INC(val)           do { __atomic_add_fetch(val, 1, __ATOMIC_RELAXED); } while (0)
>                                           ^
>src/http_act.c:638:4: warning: large atomic operation may incur significant performance penalty [-Watomic-alignment]
>                        _HA_ATOMIC_INC(&s->be->be_counters.failed_rewrites);
>                        ^
>include/haproxy/atomic.h:439:44: note: expanded from macro '_HA_ATOMIC_INC'
>#define _HA_ATOMIC_INC(val)           do { __atomic_add_fetch(val, 1, __ATOMIC_RELAXED); } while (0)
>                                           ^
>src/http_act.c:640:4: warning: large atomic operation may incur significant performance penalty [-Watomic-alignment]
>                        _HA_ATOMIC_INC(&sess->listener->counters->failed_rewrites);
>                        ^
>include/haproxy/atomic.h:439:44: note: expanded from macro '_HA_ATOMIC_INC'
>#define _HA_ATOMIC_INC(val)           do { __atomic_add_fetch(val, 1, __ATOMIC_RELAXED); } while (0)
>                                           ^
>src/http_act.c:642:4: warning: large atomic operation may incur significant performance penalty [-Watomic-alignment]
>                        _HA_ATOMIC_INC(&__objt_server(s->target)->counters.failed_rewrites);
>                        ^
>include/haproxy/atomic.h:439:44: note: expanded from macro '_HA_ATOMIC_INC'
>#define _HA_ATOMIC_INC(val)           do { __atomic_add_fetch(val, 1, __ATOMIC_RELAXED); } while (0)
>                                           ^
>29 warnings generated.
>  CC      src/stream_interface.o
>  CC      src/http_fetch.o
>  CC      src/listener.o
>In file included from src/listener.c:32:
>include/haproxy/proxy.h:125:2: warning: large atomic operation may incur significant performance penalty [-Watomic-alignment]
>        _HA_ATOMIC_INC(&fe->fe_counters.cum_conn);
>        ^
>include/haproxy/atomic.h:439:44: note: expanded from macro '_HA_ATOMIC_INC'
>#define _HA_ATOMIC_INC(val)           do { __atomic_add_fetch(val, 1, __ATOMIC_RELAXED); } while (0)
>                                           ^
>In file included from src/listener.c:32:
>include/haproxy/proxy.h:127:3: warning: large atomic operation may incur significant performance penalty [-Watomic-alignment]
>                _HA_ATOMIC_INC(&l->counters->cum_conn);
>                ^
>include/haproxy/atomic.h:439:44: note: expanded from macro '_HA_ATOMIC_INC'
>#define _HA_ATOMIC_INC(val)           do { __atomic_add_fetch(val, 1, __ATOMIC_RELAXED); } while (0)
>                                           ^
>2 warnings generated.
>  CC      src/dns.o
>  CC      src/connection.o
>  CC      src/tcp_rules.o
>src/tcp_rules.c:213:2: warning: large atomic operation may incur significant performance penalty [-Watomic-alignment]
>        _HA_ATOMIC_INC(&sess->fe->fe_counters.denied_req);
>        ^
>include/haproxy/atomic.h:439:44: note: expanded from macro '_HA_ATOMIC_INC'
>#define _HA_ATOMIC_INC(val)           do { __atomic_add_fetch(val, 1, __ATOMIC_RELAXED); } while (0)
>                                           ^
>src/tcp_rules.c:215:3: warning: large atomic operation may incur significant performance penalty [-Watomic-alignment]
>                _HA_ATOMIC_INC(&sess->listener->counters->denied_req);
>                ^
>include/haproxy/atomic.h:439:44: note: expanded from macro '_HA_ATOMIC_INC'
>#define _HA_ATOMIC_INC(val)           do { __atomic_add_fetch(val, 1, __ATOMIC_RELAXED); } while (0)
>                                           ^
>src/tcp_rules.c:219:2: warning: large atomic operation may incur significant performance penalty [-Watomic-alignment]
>        _HA_ATOMIC_INC(&sess->fe->fe_counters.internal_errors);
>        ^
>include/haproxy/atomic.h:439:44: note: expanded from macro '_HA_ATOMIC_INC'
>#define _HA_ATOMIC_INC(val)           do { __atomic_add_fetch(val, 1, __ATOMIC_RELAXED); } while (0)
>                                           ^
>src/tcp_rules.c:221:3: warning: large atomic operation may incur significant performance penalty [-Watomic-alignment]
>                _HA_ATOMIC_INC(&sess->listener->counters->internal_errors);
>                ^
>include/haproxy/atomic.h:439:44: note: expanded from macro '_HA_ATOMIC_INC'
>#define _HA_ATOMIC_INC(val)           do { __atomic_add_fetch(val, 1, __ATOMIC_RELAXED); } while (0)
>                                           ^
>src/tcp_rules.c:227:2: warning: large atomic operation may incur significant performance penalty [-Watomic-alignment]
>        _HA_ATOMIC_INC(&sess->fe->fe_counters.failed_req);
>        ^
>include/haproxy/atomic.h:439:44: note: expanded from macro '_HA_ATOMIC_INC'
>#define _HA_ATOMIC_INC(val)           do { __atomic_add_fetch(val, 1, __ATOMIC_RELAXED); } while (0)
>                                           ^
>src/tcp_rules.c:229:3: warning: large atomic operation may incur significant performance penalty [-Watomic-alignment]
>                _HA_ATOMIC_INC(&sess->listener->counters->failed_req);
>                ^
>include/haproxy/atomic.h:439:44: note: expanded from macro '_HA_ATOMIC_INC'
>#define _HA_ATOMIC_INC(val)           do { __atomic_add_fetch(val, 1, __ATOMIC_RELAXED); } while (0)
>                                           ^
>src/tcp_rules.c:376:2: warning: large atomic operation may incur significant performance penalty [-Watomic-alignment]
>        _HA_ATOMIC_INC(&s->sess->fe->fe_counters.denied_resp);
>        ^
>include/haproxy/atomic.h:439:44: note: expanded from macro '_HA_ATOMIC_INC'
>#define _HA_ATOMIC_INC(val)           do { __atomic_add_fetch(val, 1, __ATOMIC_RELAXED); } while (0)
>                                           ^
>src/tcp_rules.c:377:2: warning: large atomic operation may incur significant performance penalty [-Watomic-alignment]
>        _HA_ATOMIC_INC(&s->be->be_counters.denied_resp);
>        ^
>include/haproxy/atomic.h:439:44: note: expanded from macro '_HA_ATOMIC_INC'
>#define _HA_ATOMIC_INC(val)           do { __atomic_add_fetch(val, 1, __ATOMIC_RELAXED); } while (0)
>                                           ^
>src/tcp_rules.c:379:3: warning: large atomic operation may incur significant performance penalty [-Watomic-alignment]
>                _HA_ATOMIC_INC(&s->sess->listener->counters->denied_resp);
>                ^
>include/haproxy/atomic.h:439:44: note: expanded from macro '_HA_ATOMIC_INC'
>#define _HA_ATOMIC_INC(val)           do { __atomic_add_fetch(val, 1, __ATOMIC_RELAXED); } while (0)
>                                           ^
>src/tcp_rules.c:381:3: warning: large atomic operation may incur significant performance penalty [-Watomic-alignment]
>                _HA_ATOMIC_INC(&__objt_server(s->target)->counters.denied_resp);
>                ^
>include/haproxy/atomic.h:439:44: note: expanded from macro '_HA_ATOMIC_INC'
>#define _HA_ATOMIC_INC(val)           do { __atomic_add_fetch(val, 1, __ATOMIC_RELAXED); } while (0)
>                                           ^
>src/tcp_rules.c:385:2: warning: large atomic operation may incur significant performance penalty [-Watomic-alignment]
>        _HA_ATOMIC_INC(&s->sess->fe->fe_counters.internal_errors);
>        ^
>include/haproxy/atomic.h:439:44: note: expanded from macro '_HA_ATOMIC_INC'
>#define _HA_ATOMIC_INC(val)           do { __atomic_add_fetch(val, 1, __ATOMIC_RELAXED); } while (0)
>                                           ^
>src/tcp_rules.c:386:2: warning: large atomic operation may incur significant performance penalty [-Watomic-alignment]
>        _HA_ATOMIC_INC(&s->be->be_counters.internal_errors);
>        ^
>include/haproxy/atomic.h:439:44: note: expanded from macro '_HA_ATOMIC_INC'
>#define _HA_ATOMIC_INC(val)           do { __atomic_add_fetch(val, 1, __ATOMIC_RELAXED); } while (0)
>                                           ^
>src/tcp_rules.c:388:3: warning: large atomic operation may incur significant performance penalty [-Watomic-alignment]
>                _HA_ATOMIC_INC(&s->sess->listener->counters->internal_errors);
>                ^
>include/haproxy/atomic.h:439:44: note: expanded from macro '_HA_ATOMIC_INC'
>#define _HA_ATOMIC_INC(val)           do { __atomic_add_fetch(val, 1, __ATOMIC_RELAXED); } while (0)
>                                           ^
>src/tcp_rules.c:390:3: warning: large atomic operation may incur significant performance penalty [-Watomic-alignment]
>                _HA_ATOMIC_INC(&__objt_server(s->target)->counters.internal_errors);
>                ^
>include/haproxy/atomic.h:439:44: note: expanded from macro '_HA_ATOMIC_INC'
>#define _HA_ATOMIC_INC(val)           do { __atomic_add_fetch(val, 1, __ATOMIC_RELAXED); } while (0)
>                                           ^
>src/tcp_rules.c:396:2: warning: large atomic operation may incur significant performance penalty [-Watomic-alignment]
>        _HA_ATOMIC_INC(&s->be->be_counters.failed_resp);
>        ^
>include/haproxy/atomic.h:439:44: note: expanded from macro '_HA_ATOMIC_INC'
>#define _HA_ATOMIC_INC(val)           do { __atomic_add_fetch(val, 1, __ATOMIC_RELAXED); } while (0)
>                                           ^
>src/tcp_rules.c:398:3: warning: large atomic operation may incur significant performance penalty [-Watomic-alignment]
>                _HA_ATOMIC_INC(&__objt_server(s->target)->counters.failed_resp);
>                ^
>include/haproxy/atomic.h:439:44: note: expanded from macro '_HA_ATOMIC_INC'
>#define _HA_ATOMIC_INC(val)           do { __atomic_add_fetch(val, 1, __ATOMIC_RELAXED); } while (0)
>                                           ^
>src/tcp_rules.c:473:5: warning: large atomic operation may incur significant performance penalty [-Watomic-alignment]
>                                _HA_ATOMIC_INC(&sess->fe->fe_counters.denied_conn);
>                                ^
>include/haproxy/atomic.h:439:44: note: expanded from macro '_HA_ATOMIC_INC'
>#define _HA_ATOMIC_INC(val)           do { __atomic_add_fetch(val, 1, __ATOMIC_RELAXED); } while (0)
>                                           ^
>src/tcp_rules.c:475:6: warning: large atomic operation may incur significant performance penalty [-Watomic-alignment]
>                                        _HA_ATOMIC_INC(&sess->listener->counters->denied_conn);
>                                        ^
>include/haproxy/atomic.h:439:44: note: expanded from macro '_HA_ATOMIC_INC'
>#define _HA_ATOMIC_INC(val)           do { __atomic_add_fetch(val, 1, __ATOMIC_RELAXED); } while (0)
>                                           ^
>src/tcp_rules.c:558:5: warning: large atomic operation may incur significant performance penalty [-Watomic-alignment]
>                                _HA_ATOMIC_INC(&sess->fe->fe_counters.denied_sess);
>                                ^
>include/haproxy/atomic.h:439:44: note: expanded from macro '_HA_ATOMIC_INC'
>#define _HA_ATOMIC_INC(val)           do { __atomic_add_fetch(val, 1, __ATOMIC_RELAXED); } while (0)
>                                           ^
>src/tcp_rules.c:560:6: warning: large atomic operation may incur significant performance penalty [-Watomic-alignment]
>                                        _HA_ATOMIC_INC(&sess->listener->counters->denied_sess);
>                                        ^
>include/haproxy/atomic.h:439:44: note: expanded from macro '_HA_ATOMIC_INC'
>#define _HA_ATOMIC_INC(val)           do { __atomic_add_fetch(val, 1, __ATOMIC_RELAXED); } while (0)
>                                           ^
>20 warnings generated.
>  CC      src/debug.o
>  CC      src/sink.o
>  CC      src/payload.o
>  CC      src/mux_pt.o
>  CC      src/filters.o
>  CC      src/fcgi-app.o
>src/fcgi-app.c:477:2: warning: large atomic operation may incur significant performance penalty [-Watomic-alignment]
>        _HA_ATOMIC_INC(&sess->fe->fe_counters.failed_rewrites);
>        ^
>include/haproxy/atomic.h:439:44: note: expanded from macro '_HA_ATOMIC_INC'
>#define _HA_ATOMIC_INC(val)           do { __atomic_add_fetch(val, 1, __ATOMIC_RELAXED); } while (0)
>                                           ^
>src/fcgi-app.c:478:2: warning: large atomic operation may incur significant performance penalty [-Watomic-alignment]
>        _HA_ATOMIC_INC(&s->be->be_counters.failed_rewrites);
>        ^
>include/haproxy/atomic.h:439:44: note: expanded from macro '_HA_ATOMIC_INC'
>#define _HA_ATOMIC_INC(val)           do { __atomic_add_fetch(val, 1, __ATOMIC_RELAXED); } while (0)
>                                           ^
>src/fcgi-app.c:480:3: warning: large atomic operation may incur significant performance penalty [-Watomic-alignment]
>                _HA_ATOMIC_INC(&sess->listener->counters->failed_rewrites);
>                ^
>include/haproxy/atomic.h:439:44: note: expanded from macro '_HA_ATOMIC_INC'
>#define _HA_ATOMIC_INC(val)           do { __atomic_add_fetch(val, 1, __ATOMIC_RELAXED); } while (0)
>                                           ^
>src/fcgi-app.c:482:3: warning: large atomic operation may incur significant performance penalty [-Watomic-alignment]
>                _HA_ATOMIC_INC(&__objt_server(s->target)->counters.failed_rewrites);
>                ^
>include/haproxy/atomic.h:439:44: note: expanded from macro '_HA_ATOMIC_INC'
>#define _HA_ATOMIC_INC(val)           do { __atomic_add_fetch(val, 1, __ATOMIC_RELAXED); } while (0)
>                                           ^
>4 warnings generated.
>  CC      src/server_state.o
>  CC      src/vars.o
>  CC      src/map.o
>  CC      src/cfgparse-global.o
>  CC      src/task.o
>src/task.c:527:5: warning: large atomic operation may incur significant performance penalty [-Watomic-alignment]
>                                HA_ATOMIC_INC(&profile_entry->calls);
>                                ^
>include/haproxy/atomic.h:317:43: note: expanded from macro 'HA_ATOMIC_INC'
>#define HA_ATOMIC_INC(val)           do { __atomic_add_fetch(val, 1, __ATOMIC_SEQ_CST); } while (0)
>                                          ^
>src/task.c:528:5: warning: large atomic operation may incur significant performance penalty [-Watomic-alignment]
>                                HA_ATOMIC_ADD(&profile_entry->cpu_time, now_mono_time() - before);
>                                ^
>include/haproxy/atomic.h:315:43: note: expanded from macro 'HA_ATOMIC_ADD'
>#define HA_ATOMIC_ADD(val, i)        do { __atomic_add_fetch(val, i, __ATOMIC_SEQ_CST); } while (0)
>                                          ^
>src/task.c:556:4: warning: large atomic operation may incur significant performance penalty [-Watomic-alignment]
>                        HA_ATOMIC_ADD(&profile_entry->lat_time, lat);
>                        ^
>include/haproxy/atomic.h:315:43: note: expanded from macro 'HA_ATOMIC_ADD'
>#define HA_ATOMIC_ADD(val, i)        do { __atomic_add_fetch(val, i, __ATOMIC_SEQ_CST); } while (0)
>                                          ^
>src/task.c:557:4: warning: large atomic operation may incur significant performance penalty [-Watomic-alignment]
>                        HA_ATOMIC_INC(&profile_entry->calls);
>                        ^
>include/haproxy/atomic.h:317:43: note: expanded from macro 'HA_ATOMIC_INC'
>#define HA_ATOMIC_INC(val)           do { __atomic_add_fetch(val, 1, __ATOMIC_SEQ_CST); } while (0)
>                                          ^
>src/task.c:592:5: warning: large atomic operation may incur significant performance penalty [-Watomic-alignment]
>                                HA_ATOMIC_ADD(&profile_entry->cpu_time, cpu);
>                                ^
>include/haproxy/atomic.h:315:43: note: expanded from macro 'HA_ATOMIC_ADD'
>#define HA_ATOMIC_ADD(val, i)        do { __atomic_add_fetch(val, i, __ATOMIC_SEQ_CST); } while (0)
>                                          ^
>5 warnings generated.
>  CC      src/flt_http_comp.o
>src/flt_http_comp.c:266:3: warning: large atomic operation may incur significant performance penalty [-Watomic-alignment]
>                _HA_ATOMIC_ADD(&strm_fe(s)->fe_counters.comp_in, consumed);
>                ^
>include/haproxy/atomic.h:437:44: note: expanded from macro '_HA_ATOMIC_ADD'
>#define _HA_ATOMIC_ADD(val, i)        do { __atomic_add_fetch(val, i, __ATOMIC_RELAXED); } while (0)
>                                           ^
>src/flt_http_comp.c:267:3: warning: large atomic operation may incur significant performance penalty [-Watomic-alignment]
>                _HA_ATOMIC_ADD(&s->be->be_counters.comp_in, consumed);
>                ^
>include/haproxy/atomic.h:437:44: note: expanded from macro '_HA_ATOMIC_ADD'
>#define _HA_ATOMIC_ADD(val, i)        do { __atomic_add_fetch(val, i, __ATOMIC_RELAXED); } while (0)
>                                           ^
>src/flt_http_comp.c:269:3: warning: large atomic operation may incur significant performance penalty [-Watomic-alignment]
>                _HA_ATOMIC_ADD(&strm_fe(s)->fe_counters.comp_out, to_forward);
>                ^
>include/haproxy/atomic.h:437:44: note: expanded from macro '_HA_ATOMIC_ADD'
>#define _HA_ATOMIC_ADD(val, i)        do { __atomic_add_fetch(val, i, __ATOMIC_RELAXED); } while (0)
>                                           ^
>src/flt_http_comp.c:270:3: warning: large atomic operation may incur significant performance penalty [-Watomic-alignment]
>                _HA_ATOMIC_ADD(&s->be->be_counters.comp_out, to_forward);
>                ^
>include/haproxy/atomic.h:437:44: note: expanded from macro '_HA_ATOMIC_ADD'
>#define _HA_ATOMIC_ADD(val, i)        do { __atomic_add_fetch(val, i, __ATOMIC_RELAXED); } while (0)
>                                           ^
>src/flt_http_comp.c:272:3: warning: large atomic operation may incur significant performance penalty [-Watomic-alignment]
>                _HA_ATOMIC_ADD(&strm_fe(s)->fe_counters.comp_byp, consumed);
>                ^
>include/haproxy/atomic.h:437:44: note: expanded from macro '_HA_ATOMIC_ADD'
>#define _HA_ATOMIC_ADD(val, i)        do { __atomic_add_fetch(val, i, __ATOMIC_RELAXED); } while (0)
>                                           ^
>src/flt_http_comp.c:273:3: warning: large atomic operation may incur significant performance penalty [-Watomic-alignment]
>                _HA_ATOMIC_ADD(&s->be->be_counters.comp_byp, consumed);
>                ^
>include/haproxy/atomic.h:437:44: note: expanded from macro '_HA_ATOMIC_ADD'
>#define _HA_ATOMIC_ADD(val, i)        do { __atomic_add_fetch(val, i, __ATOMIC_RELAXED); } while (0)
>                                           ^
>src/flt_http_comp.c:292:3: warning: large atomic operation may incur significant performance penalty [-Watomic-alignment]
>                _HA_ATOMIC_INC(&strm_fe(s)->fe_counters.p.http.comp_rsp);
>                ^
>include/haproxy/atomic.h:439:44: note: expanded from macro '_HA_ATOMIC_INC'
>#define _HA_ATOMIC_INC(val)           do { __atomic_add_fetch(val, 1, __ATOMIC_RELAXED); } while (0)
>                                           ^
>src/flt_http_comp.c:294:3: warning: large atomic operation may incur significant performance penalty [-Watomic-alignment]
>                _HA_ATOMIC_INC(&s->be->be_counters.p.http.comp_rsp);
>                ^
>include/haproxy/atomic.h:439:44: note: expanded from macro '_HA_ATOMIC_INC'
>#define _HA_ATOMIC_INC(val)           do { __atomic_add_fetch(val, 1, __ATOMIC_RELAXED); } while (0)
>                                           ^
>8 warnings generated.
>  CC      src/session.o
>In file included from src/session.c:20:
>include/haproxy/proxy.h:136:2: warning: large atomic operation may incur significant performance penalty [-Watomic-alignment]
>        _HA_ATOMIC_INC(&fe->fe_counters.cum_sess);
>        ^
>include/haproxy/atomic.h:439:44: note: expanded from macro '_HA_ATOMIC_INC'
>#define _HA_ATOMIC_INC(val)           do { __atomic_add_fetch(val, 1, __ATOMIC_RELAXED); } while (0)
>                                           ^
>In file included from src/session.c:20:
>include/haproxy/proxy.h:138:3: warning: large atomic operation may incur significant performance penalty [-Watomic-alignment]
>                _HA_ATOMIC_INC(&l->counters->cum_sess);
>                ^
>include/haproxy/atomic.h:439:44: note: expanded from macro '_HA_ATOMIC_INC'
>#define _HA_ATOMIC_INC(val)           do { __atomic_add_fetch(val, 1, __ATOMIC_RELAXED); } while (0)
>                                           ^
>2 warnings generated.
>  CC      src/sock.o
>  CC      src/flt_trace.o
>  CC      src/acl.o
>  CC      src/trace.o
>src/trace.c:360:4: warning: large atomic operation may incur significant performance penalty [-Watomic-alignment]
>                        HA_ATOMIC_STORE(ev_ptr, 0);
>                        ^
>include/haproxy/atomic.h:309:38: note: expanded from macro 'HA_ATOMIC_STORE'
>#define HA_ATOMIC_STORE(val, new)    __atomic_store_n(val, new, __ATOMIC_SEQ_CST)
>                                     ^
>src/trace.c:376:4: warning: large atomic operation may incur significant performance penalty [-Watomic-alignment]
>                        HA_ATOMIC_STORE(ev_ptr, 0);
>                        ^
>include/haproxy/atomic.h:309:38: note: expanded from macro 'HA_ATOMIC_STORE'
>#define HA_ATOMIC_STORE(val, new)    __atomic_store_n(val, new, __ATOMIC_SEQ_CST)
>                                     ^
>src/trace.c:378:4: warning: large atomic operation may incur significant performance penalty [-Watomic-alignment]
>                        HA_ATOMIC_STORE(ev_ptr, ~0);
>                        ^
>include/haproxy/atomic.h:309:38: note: expanded from macro 'HA_ATOMIC_STORE'
>#define HA_ATOMIC_STORE(val, new)    __atomic_store_n(val, new, __ATOMIC_SEQ_CST)
>                                     ^
>src/trace.c:385:5: warning: large atomic operation may incur significant performance penalty [-Watomic-alignment]
>                                HA_ATOMIC_OR(ev_ptr, ev->mask);
>                                ^
>include/haproxy/atomic.h:314:43: note: expanded from macro 'HA_ATOMIC_OR'
>#define HA_ATOMIC_OR(val, flags)     do { __atomic_or_fetch(val,  flags, __ATOMIC_SEQ_CST); } while (0)
>                                          ^
>src/trace.c:387:5: warning: large atomic operation may incur significant performance penalty [-Watomic-alignment]
>                                HA_ATOMIC_AND(ev_ptr, ~ev->mask);
>                                ^
>include/haproxy/atomic.h:313:43: note: expanded from macro 'HA_ATOMIC_AND'
>#define HA_ATOMIC_AND(val, flags)    do { __atomic_and_fetch(val, flags, __ATOMIC_SEQ_CST); } while (0)
>                                          ^
>5 warnings generated.
>  CC      src/http_rules.o
>  CC      src/queue.o
>  CC      src/mjson.o
>  CC      src/h2.o
>  CC      src/h1.o
>  CC      src/mworker.o
>  CC      src/lb_chash.o
>  CC      src/ring.o
>  CC      src/activity.o
>src/activity.c:445:4: warning: large atomic operation may incur significant performance penalty [-Watomic-alignment]
>                        HA_ATOMIC_STORE(&sched_activity[i].calls, 0);
>                        ^
>include/haproxy/atomic.h:309:38: note: expanded from macro 'HA_ATOMIC_STORE'
>#define HA_ATOMIC_STORE(val, new)    __atomic_store_n(val, new, __ATOMIC_SEQ_CST)
>                                     ^
>src/activity.c:446:4: warning: large atomic operation may incur significant performance penalty [-Watomic-alignment]
>                        HA_ATOMIC_STORE(&sched_activity[i].cpu_time, 0);
>                        ^
>include/haproxy/atomic.h:309:38: note: expanded from macro 'HA_ATOMIC_STORE'
>#define HA_ATOMIC_STORE(val, new)    __atomic_store_n(val, new, __ATOMIC_SEQ_CST)
>                                     ^
>src/activity.c:447:4: warning: large atomic operation may incur significant performance penalty [-Watomic-alignment]
>                        HA_ATOMIC_STORE(&sched_activity[i].lat_time, 0);
>                        ^
>include/haproxy/atomic.h:309:38: note: expanded from macro 'HA_ATOMIC_STORE'
>#define HA_ATOMIC_STORE(val, new)    __atomic_store_n(val, new, __ATOMIC_SEQ_CST)
>                                     ^
>3 warnings generated.
>  CC      src/tcp_sample.o
>  CC      src/proto_tcp.o
>  CC      src/htx.o
>  CC      src/h1_htx.o
>  CC      src/extcheck.o
>  CC      src/channel.o
>  CC      src/proto_sockpair.o
>  CC      src/fd.o
>  CC      src/compression.o
>  CC      src/mqtt.o
>  CC      src/tcp_act.o
>src/tcp_act.c:225:4: warning: large atomic operation may incur significant performance penalty [-Watomic-alignment]
>                        _HA_ATOMIC_INC(&strm->be->be_counters.denied_req);
>                        ^
>include/haproxy/atomic.h:439:44: note: expanded from macro '_HA_ATOMIC_INC'
>#define _HA_ATOMIC_INC(val)           do { __atomic_add_fetch(val, 1, __ATOMIC_RELAXED); } while (0)
>                                           ^
>src/tcp_act.c:232:2: warning: large atomic operation may incur significant performance penalty [-Watomic-alignment]
>        _HA_ATOMIC_INC(&sess->fe->fe_counters.denied_req);
>        ^
>include/haproxy/atomic.h:439:44: note: expanded from macro '_HA_ATOMIC_INC'
>#define _HA_ATOMIC_INC(val)           do { __atomic_add_fetch(val, 1, __ATOMIC_RELAXED); } while (0)
>                                           ^
>src/tcp_act.c:234:3: warning: large atomic operation may incur significant performance penalty [-Watomic-alignment]
>                _HA_ATOMIC_INC(&sess->listener->counters->denied_req);
>                ^
>include/haproxy/atomic.h:439:44: note: expanded from macro '_HA_ATOMIC_INC'
>#define _HA_ATOMIC_INC(val)           do { __atomic_add_fetch(val, 1, __ATOMIC_RELAXED); } while (0)
>                                           ^
>3 warnings generated.
>  CC      src/raw_sock.o
>src/raw_sock.c:412:3: warning: large atomic operation may incur significant performance penalty [-Watomic-alignment]
>                _HA_ATOMIC_ADD(&global.out_bytes, done);
>                ^
>include/haproxy/atomic.h:437:44: note: expanded from macro '_HA_ATOMIC_ADD'
>#define _HA_ATOMIC_ADD(val, i)        do { __atomic_add_fetch(val, i, __ATOMIC_RELAXED); } while (0)
>                                           ^
>1 warning generated.
>  CC      src/frontend.o
>  CC      src/http_conv.o
>  CC      src/xprt_handshake.o
>  CC      src/pool.o
>  CC      src/applet.o
>  CC      src/mailers.o
>  CC      src/lb_fwrr.o
>  CC      src/lb_fwlc.o
>  CC      src/lb_fas.o
>  CC      src/proto_uxst.o
>  CC      src/http.o
>  CC      src/action.o
>  CC      src/protocol.o
>  CC      src/thread.o
>  CC      src/sock_unix.o
>  CC      src/proto_udp.o
>  CC      src/lb_map.o
>  CC      src/sock_inet.o
>  CC      src/lru.o
>  CC      src/cfgparse-tcp.o
>  CC      src/cfgdiag.o
>  CC      src/proto_uxdg.o
>  CC      src/ev_select.o
>  CC      src/cfgparse-unix.o
>  CC      src/uri_normalizer.o
>  CC      src/ebmbtree.o
>  CC      src/sha1.o
>  CC      src/time.o
>src/time.c:206:8: warning: large atomic operation may incur significant performance penalty [-Watomic-alignment]
>        ofs = HA_ATOMIC_LOAD(&now_offset);
>              ^
>include/haproxy/atomic.h:310:38: note: expanded from macro 'HA_ATOMIC_LOAD'
>#define HA_ATOMIC_LOAD(val)          __atomic_load_n(val, __ATOMIC_SEQ_CST)
>                                     ^
>src/time.c:252:39: warning: large atomic operation may incur significant performance penalty [-Watomic-alignment]
>        } while (((new_now != old_now    && !_HA_ATOMIC_CAS(&global_now, &old_now, new_now)) ||
>                                             ^
>include/haproxy/atomic.h:518:39: note: expanded from macro '_HA_ATOMIC_CAS'
>#define _HA_ATOMIC_CAS(val, old, new) __atomic_compare_exchange_n(val, old, new, 0, __ATOMIC_RELAXED, __ATOMIC_RELAXED)
>                                      ^
>src/time.c:270:3: warning: large atomic operation may incur significant performance penalty [-Watomic-alignment]
>                HA_ATOMIC_STORE(&now_offset, ofs_new);
>                ^
>include/haproxy/atomic.h:309:38: note: expanded from macro 'HA_ATOMIC_STORE'
>#define HA_ATOMIC_STORE(val, new)    __atomic_store_n(val, new, __ATOMIC_SEQ_CST)
>                                     ^
>src/time.c:296:12: warning: large atomic operation may incur significant performance penalty [-Watomic-alignment]
>        old_now = _HA_ATOMIC_LOAD(&global_now);
>                  ^
>include/haproxy/atomic.h:431:39: note: expanded from macro '_HA_ATOMIC_LOAD'
>#define _HA_ATOMIC_LOAD(val)          __atomic_load_n(val, __ATOMIC_RELAXED)
>                                      ^
>4 warnings generated.
>  CC      src/signal.o
>  CC      src/mworker-prog.o
>  CC      src/hpack-dec.o
>  CC      src/fix.o
>  CC      src/arg.o
>  CC      src/eb64tree.o
>  CC      src/chunk.o
>  CC      src/shctx.o
>  CC      src/regex.o
>  CC      src/fcgi.o
>  CC      src/eb32tree.o
>  CC      src/eb32sctree.o
>  CC      src/dynbuf.o
>  CC      src/uri_auth.o
>  CC      src/hpack-tbl.o
>  CC      src/ebimtree.o
>  CC      src/auth.o
>  CC      src/ebsttree.o
>  CC      src/ebistree.o
>  CC      src/base64.o
>  CC      src/wdt.o
>  CC      src/pipe.o
>  CC      src/http_acl.o
>  CC      src/hpack-enc.o
>  CC      src/dict.o
>  CC      src/dgram.o
>  CC      src/init.o
>  CC      src/hpack-huff.o
>  CC      src/freq_ctr.o
>  CC      src/ebtree.o
>  CC      src/hash.o
>  CC      src/version.o
>  LD      haproxy
>ld: error: unable to find library -latomic
>cc: error: linker command failed with exit code 1 (use -v to see invocation)
>gmake[1]: *** [Makefile:948: haproxy] Error 1
>gmake[1]: Leaving directory '/wrkdirs/usr/ports/net/haproxy/work-default/haproxy-2.4.9'
>*** Error code 1
>
>Stop.
>make: stopped in /usr/ports/net/haproxy
>=>> Cleaning up wrkdir
>===>  Cleaning for haproxy-2.4.9
>build of net/haproxy | haproxy-2.4.9 ended at Mon Dec 20 01:13:25 +07 2021
>build time: 00:03:05
>!!! build failure encountered !!!

Actions: View

Attachments on bug 260555: 230255