From nobody Fri Oct 25 17:24:13 2024 Delivered-To: importer@patchew.org Authentication-Results: mx.zohomail.com; dkim=pass; spf=pass (zohomail.com: domain of gnu.org designates 209.51.188.17 as permitted sender) smtp.mailfrom=qemu-devel-bounces+importer=patchew.org@nongnu.org; dmarc=pass(p=none dis=none) header.from=linaro.org ARC-Seal: i=1; a=rsa-sha256; t=1718043847; cv=none; d=zohomail.com; s=zohoarc; b=ampDUEjB9lENG3BS4XE8bnKeXcObj83m9NtJrzuJQyY4xiObhtoq819+J0hvgnihbigRf2x1wSzJbIjjEXHwz8SSFmHKXpi00X/tMjShNABAKnT6PfznSKmqKUut+5bESSXztWgFpnhIU7DDvW0TyY01UcphA4pT1ZlSvhZubPg= ARC-Message-Signature: i=1; a=rsa-sha256; c=relaxed/relaxed; d=zohomail.com; s=zohoarc; t=1718043847; h=Content-Type:Content-Transfer-Encoding:Cc:Cc:Date:Date:From:From:In-Reply-To:List-Subscribe:List-Post:List-Id:List-Archive:List-Help:List-Unsubscribe:MIME-Version:Message-ID:References:Sender:Subject:Subject:To:To:Message-Id:Reply-To; bh=afpTvlZORsXSvASDQXonBq/USkVt1IMjvvOgb9vVaOU=; b=YtVjeLrg80+rpCJwz6B7RzxDv3JvZ0TbQ+B8o0wWxYjHVgHxP0ItQqqXKWUCWOhvNxkabij1EbHWOLUx6VeBfiP/zAi0JWmDpkUCCWxSGQSXgxXJT74BGJGU9iA+aDG8lEnZmJDkttDpzNeG326jSbuR8Y5LYaiHbBN4loNtMoA= ARC-Authentication-Results: i=1; mx.zohomail.com; dkim=pass; spf=pass (zohomail.com: domain of gnu.org designates 209.51.188.17 as permitted sender) smtp.mailfrom=qemu-devel-bounces+importer=patchew.org@nongnu.org; dmarc=pass header.from= (p=none dis=none) Return-Path: Received: from lists.gnu.org (lists.gnu.org [209.51.188.17]) by mx.zohomail.com with SMTPS id 1718043847463702.6359181124014; Mon, 10 Jun 2024 11:24:07 -0700 (PDT) Received: from localhost ([::1] helo=lists1p.gnu.org) by lists.gnu.org with esmtp (Exim 4.90_1) (envelope-from ) id 1sGjfo-0000OO-Qh; Mon, 10 Jun 2024 14:23:16 -0400 Received: from eggs.gnu.org ([2001:470:142:3::10]) by lists.gnu.org with esmtps (TLS1.2:ECDHE_RSA_AES_256_GCM_SHA384:256) (Exim 4.90_1) (envelope-from ) id 1sGjfn-0000No-6m for qemu-devel@nongnu.org; Mon, 10 Jun 2024 14:23:15 -0400 Received: from mail-lj1-x229.google.com ([2a00:1450:4864:20::229]) by eggs.gnu.org with esmtps (TLS1.2:ECDHE_RSA_AES_128_GCM_SHA256:128) (Exim 4.90_1) (envelope-from ) id 1sGjfk-00069M-RP for qemu-devel@nongnu.org; Mon, 10 Jun 2024 14:23:14 -0400 Received: by mail-lj1-x229.google.com with SMTP id 38308e7fff4ca-2eae2d4daf0so1818311fa.2 for ; Mon, 10 Jun 2024 11:23:12 -0700 (PDT) Received: from localhost.localdomain (adsl-33.37.6.162.tellas.gr. [37.6.162.33]) by smtp.gmail.com with ESMTPSA id 5b1f17b1804b1-42161147811sm135487395e9.18.2024.06.10.11.23.08 (version=TLS1_3 cipher=TLS_AES_256_GCM_SHA384 bits=256/256); Mon, 10 Jun 2024 11:23:10 -0700 (PDT) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=linaro.org; s=google; t=1718043791; x=1718648591; darn=nongnu.org; h=content-transfer-encoding:mime-version:references:in-reply-to :message-id:date:subject:cc:to:from:from:to:cc:subject:date :message-id:reply-to; bh=afpTvlZORsXSvASDQXonBq/USkVt1IMjvvOgb9vVaOU=; b=ib/jTBfu35A/JtjV3cRwIm6QU5PDtc73VctvRLYkBZqegodVfptZ174g/L1ahdwmIz VtWZlIe99IvtoBqR8I/l0lW2zAYdI7kExxgutiMBh7iYUPDux3sQw6utKGtRh8NVYgHg UDO7L42pVpIxIyjJ4DjCEwxsYFOaxszq1ebgNkyxTX45r9MN1flg2ivtEIWwI/sjY5WY nnlBdhIyAQW20WQ4SRXvr20erLdMv3lsmqejLDSFTXTrxGVnl5TfM8CVTgGzQS65bIXc I69t/LfRs0yOgY5/Tihh8I3EJ+YQfgoAJXN4pqfw6jI0PguZbfW7Kh2RA0KuA9IV72/4 7Zsg== X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20230601; t=1718043791; x=1718648591; h=content-transfer-encoding:mime-version:references:in-reply-to :message-id:date:subject:cc:to:from:x-gm-message-state:from:to:cc :subject:date:message-id:reply-to; bh=afpTvlZORsXSvASDQXonBq/USkVt1IMjvvOgb9vVaOU=; b=WMGnvREAIpGRKyrWUx+J0A6d0dw7UdyoBi4D55fmoIfEqcuV95L1rDsjWqckFO61ZY gafIpFeCZx7/oOuweYHiTsrgPemz1dDKqDlDto1hmYYKyqWA1OcsGmG6gbLTetY8+ttn wkCCeY5ba5k357SAarnvuWICKqCX/aClZL5RAwyrMtuOi2FYliYoXV6apqQNb5L6Ed1w R8Bu4W2EM61KCRM98XQSUedjFW4xZRew+0G82ATWrwMp3iMnUiENEJhMTyFtrolf9KFl 5M/j9TRtlq2Itkn1T0uNhOzr8FNwUP1cD00FgdKxhRPdcIjsrpQ2UMIzAwmDW03zGXEw LTlQ== X-Gm-Message-State: AOJu0YzfYm5lbtwBTlf06HXpvEi0indb6SgQHYUfrWeFlXDahmRJDnl/ v+0uOC4U9NjczEalxaoy9iwhs0iGPRrP0gz4fHY8CIRQmq1K5UIYhhwDm8Az7pwLHv5b2VJqtB0 lNnw= X-Google-Smtp-Source: AGHT+IFnSXYKapteKTWFQ2dB8/4KQS94+GdYYmswDHx9yL7+8aM/9VIY1d26Zj+snlLf5A8NFkW2lw== X-Received: by 2002:a2e:828f:0:b0:2ea:8d54:4516 with SMTP id 38308e7fff4ca-2eadce3fed0mr63302071fa.27.1718043790645; Mon, 10 Jun 2024 11:23:10 -0700 (PDT) From: Manos Pitsidianakis To: qemu-devel@nongnu.org Cc: Stefan Hajnoczi , Mads Ynddal , Paolo Bonzini , Peter Maydell , =?UTF-8?q?Alex=20Benn=C3=A9e?= , =?UTF-8?q?Daniel=20P=2E=20Berrang=C3=A9?= , =?UTF-8?q?Marc-Andr=C3=A9=20Lureau?= , Thomas Huth , Markus Armbruster , =?UTF-8?q?Philippe=20Mathieu-Daud=C3=A9?= , Zhao Liu , Gustavo Romero , Pierrick Bouvier , John Snow , Cleber Rosa Subject: [RFC PATCH v1 1/6] build-sys: Add rust feature option Date: Mon, 10 Jun 2024 21:22:36 +0300 Message-ID: <0933b669c8e47e1a78d21e56881e0933ef910461.1718040303.git.manos.pitsidianakis@linaro.org> X-Mailer: git-send-email 2.44.0 In-Reply-To: References: MIME-Version: 1.0 Content-Transfer-Encoding: quoted-printable Received-SPF: pass (zohomail.com: domain of gnu.org designates 209.51.188.17 as permitted sender) client-ip=209.51.188.17; envelope-from=qemu-devel-bounces+importer=patchew.org@nongnu.org; helo=lists.gnu.org; Received-SPF: pass client-ip=2a00:1450:4864:20::229; envelope-from=manos.pitsidianakis@linaro.org; helo=mail-lj1-x229.google.com X-Spam_score_int: -20 X-Spam_score: -2.1 X-Spam_bar: -- X-Spam_report: (-2.1 / 5.0 requ) BAYES_00=-1.9, DKIM_SIGNED=0.1, DKIM_VALID=-0.1, DKIM_VALID_AU=-0.1, DKIM_VALID_EF=-0.1, RCVD_IN_DNSWL_NONE=-0.0001, SPF_HELO_NONE=0.001, SPF_PASS=-0.001, T_SCC_BODY_TEXT_LINE=-0.01 autolearn=ham autolearn_force=no X-Spam_action: no action X-BeenThere: qemu-devel@nongnu.org X-Mailman-Version: 2.1.29 Precedence: list List-Id: List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , Errors-To: qemu-devel-bounces+importer=patchew.org@nongnu.org Sender: qemu-devel-bounces+importer=patchew.org@nongnu.org X-ZohoMail-DKIM: pass (identity @linaro.org) X-ZM-MESSAGEID: 1718043849225100002 Content-Type: text/plain; charset="utf-8" Add options for Rust in meson_options.txt, meson.build, configure to prepare for adding Rust code in the followup commits. `rust` is a reserved meson name, so we have to use an alternative. `with_rust` was chosen. Signed-off-by: Manos Pitsidianakis --- The cargo wrapper script hardcodes some rust target triples. This is=20 just temporary. --- .gitignore | 2 + configure | 12 +++ meson.build | 11 ++ meson_options.txt | 4 + scripts/cargo_wrapper.py | 211 +++++++++++++++++++++++++++++++++++++++ 5 files changed, 240 insertions(+) create mode 100644 scripts/cargo_wrapper.py diff --git a/.gitignore b/.gitignore index 61fa39967b..f42b0d937e 100644 --- a/.gitignore +++ b/.gitignore @@ -2,6 +2,8 @@ /build/ /.cache/ /.vscode/ +/target/ +rust/**/target *.pyc .sdk .stgit-* diff --git a/configure b/configure index 38ee257701..c195630771 100755 --- a/configure +++ b/configure @@ -302,6 +302,9 @@ else objcc=3D"${objcc-${cross_prefix}clang}" fi =20 +with_rust=3D"auto" +with_rust_target_triple=3D"" + ar=3D"${AR-${cross_prefix}ar}" as=3D"${AS-${cross_prefix}as}" ccas=3D"${CCAS-$cc}" @@ -760,6 +763,12 @@ for opt do ;; --gdb=3D*) gdb_bin=3D"$optarg" ;; + --enable-rust) with_rust=3Denabled + ;; + --disable-rust) with_rust=3Ddisabled + ;; + --rust-target-triple=3D*) with_rust_target_triple=3D"$optarg" + ;; # everything else has the same name in configure and meson --*) meson_option_parse "$opt" "$optarg" ;; @@ -1796,6 +1805,9 @@ if test "$skip_meson" =3D no; then test -n "${LIB_FUZZING_ENGINE+xxx}" && meson_option_add "-Dfuzzing_engin= e=3D$LIB_FUZZING_ENGINE" test "$plugins" =3D yes && meson_option_add "-Dplugins=3Dtrue" test "$tcg" !=3D enabled && meson_option_add "-Dtcg=3D$tcg" + test "$with_rust" !=3D enabled && meson_option_add "-Dwith_rust=3D$with_= rust" + test "$with_rust" !=3D enabled && meson_option_add "-Dwith_rust=3D$with_= rust" + test "$with_rust_target_triple" !=3D "" && meson_option_add "-Dwith_rust= _target_triple=3D$with_rust_target_triple" run_meson() { NINJA=3D$ninja $meson setup "$@" "$PWD" "$source_path" } diff --git a/meson.build b/meson.build index a9de71d450..3533889852 100644 --- a/meson.build +++ b/meson.build @@ -290,6 +290,12 @@ foreach lang : all_languages endif endforeach =20 +cargo =3D not_found +if get_option('with_rust').allowed() + cargo =3D find_program('cargo', required: get_option('with_rust')) +endif +with_rust =3D cargo.found() + # default flags for all hosts # We use -fwrapv to tell the compiler that we require a C dialect where # left shift of signed integers is well defined and has the expected @@ -2066,6 +2072,7 @@ endif =20 config_host_data =3D configuration_data() =20 +config_host_data.set('CONFIG_WITH_RUST', with_rust) audio_drivers_selected =3D [] if have_system audio_drivers_available =3D { @@ -4190,6 +4197,10 @@ if 'objc' in all_languages else summary_info +=3D {'Objective-C compiler': false} endif +summary_info +=3D {'Rust support': with_rust} +if with_rust and get_option('with_rust_target_triple') !=3D '' + summary_info +=3D {'Rust target': get_option('with_rust_target_tripl= e')} +endif option_cflags =3D (get_option('debug') ? ['-g'] : []) if get_option('optimization') !=3D 'plain' option_cflags +=3D ['-O' + get_option('optimization')] diff --git a/meson_options.txt b/meson_options.txt index 4c1583eb40..223491b731 100644 --- a/meson_options.txt +++ b/meson_options.txt @@ -366,3 +366,7 @@ option('qemu_ga_version', type: 'string', value: '', =20 option('hexagon_idef_parser', type : 'boolean', value : true, description: 'use idef-parser to automatically generate TCG code fo= r the Hexagon frontend') +option('with_rust', type: 'feature', value: 'auto', + description: 'Enable Rust support') +option('with_rust_target_triple', type : 'string', value: '', + description: 'Rust target triple') diff --git a/scripts/cargo_wrapper.py b/scripts/cargo_wrapper.py new file mode 100644 index 0000000000..d338effdaa --- /dev/null +++ b/scripts/cargo_wrapper.py @@ -0,0 +1,211 @@ +#!/usr/bin/env python3 +# Copyright (c) 2020 Red Hat, Inc. +# Copyright (c) 2023 Linaro Ltd. +# +# Authors: +# Manos Pitsidianakis +# Marc-Andr=C3=A9 Lureau +# +# This work is licensed under the terms of the GNU GPL, version 2 or +# later. See the COPYING file in the top-level directory. + +import argparse +import configparser +import distutils.file_util +import json +import logging +import os +import os.path +import re +import subprocess +import sys +import pathlib +import shutil +import tomllib + +from pathlib import Path +from typing import Any, Dict, List, Tuple + +RUST_TARGET_TRIPLES =3D ( + "aarch64-unknown-linux-gnu", + "x86_64-unknown-linux-gnu", + "x86_64-apple-darwin", + "aarch64-apple-darwin", +) + + +def cfg_name(name: str) -> str: + if ( + name.startswith("CONFIG_") + or name.startswith("TARGET_") + or name.startswith("HAVE_") + ): + return name + return "" + + +def generate_cfg_flags(header: str) -> List[str]: + with open(header, encoding=3D"utf-8") as cfg: + config =3D [l.split()[1:] for l in cfg if l.startswith("#define")] + + cfg_list =3D [] + for cfg in config: + name =3D cfg_name(cfg[0]) + if not name: + continue + if len(cfg) >=3D 2 and cfg[1] !=3D "1": + continue + cfg_list.append("--cfg") + cfg_list.append(name) + return cfg_list + + +def cargo_target_dir(args: argparse.Namespace) -> pathlib.Path: + return args.meson_build_dir + + +def manifest_path(args: argparse.Namespace) -> pathlib.Path: + return args.crate_dir / "Cargo.toml" + + +def get_cargo_rustc(args: argparse.Namespace) -> tuple[Dict[str, Any], Lis= t[str]]: + # See https://doc.rust-lang.org/cargo/reference/environment-variables.= html + # Item `CARGO_ENCODED_RUSTFLAGS =E2=80=94 A list of custom flags separ= ated by + # 0x1f (ASCII Unit Separator) to pass to all compiler invocations that= Cargo + # performs` + cfg =3D chr(0x1F).join( + [c for h in args.config_headers for c in generate_cfg_flags(h)] + ) + target_dir =3D cargo_target_dir(args) + cargo_path =3D manifest_path(args) + + cargo_cmd =3D [ + "cargo", + "build", + "--target-dir", + str(target_dir), + "--manifest-path", + str(cargo_path), + ] + if args.target_triple: + cargo_cmd +=3D ["--target", args.target_triple] + if args.profile =3D=3D "release": + cargo_cmd +=3D ["--release"] + + env =3D os.environ + env["CARGO_ENCODED_RUSTFLAGS"] =3D cfg + + return (env, cargo_cmd) + + +def run_cargo(env: Dict[str, Any], cargo_cmd: List[str]) -> str: + envlog =3D " ".join(["{}=3D{}".format(k, v) for k, v in env.items()]) + cmdlog =3D " ".join(cargo_cmd) + logging.debug("Running %s %s", envlog, cmdlog) + try: + out =3D subprocess.check_output( + cargo_cmd, + env=3Ddict(os.environ, **env), + stderr=3Dsubprocess.STDOUT, + universal_newlines=3DTrue, + ) + except subprocess.CalledProcessError as err: + print("Environment: " + envlog) + print("Command: " + cmdlog) + print(err.output) + sys.exit(1) + + return out + + +def build_lib(args: argparse.Namespace) -> None: + logging.debug("build-lib") + target_dir =3D cargo_target_dir(args) + cargo_toml_path =3D manifest_path(args) + + with open(cargo_toml_path, "rb") as f: + config =3D tomllib.load(f) + + package_name =3D config["package"]["name"].strip('"').replace("-", "_") + + liba_filename =3D "lib" + package_name + ".a" + liba =3D target_dir / args.target_triple / args.profile / liba_filename + + env, cargo_cmd =3D get_cargo_rustc(args) + out =3D run_cargo(env, cargo_cmd) + logging.debug("cp %s %s", liba, args.outdir) + shutil.copy2(liba, args.outdir) + + +def main() -> None: + parser =3D argparse.ArgumentParser() + parser.add_argument("-v", "--verbose", action=3D"store_true") + parser.add_argument( + "--color", + metavar=3D"WHEN", + choices=3D["auto", "always", "never"], + default=3D"auto", + help=3D"Coloring: auto, always, never", + ) + parser.add_argument( + "--config-headers", + metavar=3D"CONFIG_HEADER", + action=3D"append", + dest=3D"config_headers", + required=3DFalse, + default=3D[], + ) + parser.add_argument( + "--meson-build-dir", + metavar=3D"BUILD_DIR", + help=3D"meson.current_build_dir()", + type=3Dpathlib.Path, + dest=3D"meson_build_dir", + required=3DTrue, + ) + parser.add_argument( + "--meson-source-dir", + metavar=3D"SOURCE_DIR", + help=3D"meson.current_source_dir()", + type=3Dpathlib.Path, + dest=3D"meson_source_dir", + required=3DTrue, + ) + parser.add_argument( + "--crate-dir", + metavar=3D"CRATE_DIR", + type=3Dpathlib.Path, + dest=3D"crate_dir", + help=3D"Absolute path that contains the manifest file of the crate= to compile", + required=3DTrue, + ) + parser.add_argument( + "--outdir", + metavar=3D"OUTDIR", + type=3Dpathlib.Path, + dest=3D"outdir", + help=3D"Path to copy compiled artifacts to for Meson to use.", + required=3DTrue, + ) + parser.add_argument( + "--profile", type=3Dstr, choices=3D["release", "debug"], required= =3DTrue + ) + parser.add_argument( + "--target-triple", type=3Dstr, choices=3DRUST_TARGET_TRIPLES, requ= ired=3DTrue + ) + + subparsers =3D parser.add_subparsers() + + buildlib =3D subparsers.add_parser("build-lib") + buildlib.set_defaults(func=3Dbuild_lib) + + args =3D parser.parse_args() + if args.verbose: + logging.basicConfig(level=3Dlogging.DEBUG) + logging.debug("args: %s", args) + + args.func(args) + + +if __name__ =3D=3D "__main__": + main() --=20 =CE=B3=CE=B1=E1=BF=96=CE=B1 =CF=80=CF=85=CF=81=CE=AF =CE=BC=CE=B9=CF=87=CE= =B8=CE=AE=CF=84=CF=89 From nobody Fri Oct 25 17:24:13 2024 Delivered-To: importer@patchew.org Authentication-Results: mx.zohomail.com; dkim=pass; spf=pass (zohomail.com: domain of gnu.org designates 209.51.188.17 as permitted sender) smtp.mailfrom=qemu-devel-bounces+importer=patchew.org@nongnu.org; dmarc=pass(p=none dis=none) header.from=linaro.org ARC-Seal: i=1; a=rsa-sha256; t=1718043849; cv=none; d=zohomail.com; s=zohoarc; b=g9/m7cZU8M3K7j82JcfPuFINccZc4hN0ZZ6hnACwrhCLpekWCpW4vDHjef8zEpbdvbMZyYiB0yDHse4UuoV4phmZbkHpwFT86Jfpzle/77m7iTLdbrJZioegruzEzWsFT/kPTUNFX/HywBqLhvxP1pYG9Em6r3ZulAywYtHkfCw= ARC-Message-Signature: i=1; a=rsa-sha256; c=relaxed/relaxed; d=zohomail.com; s=zohoarc; t=1718043849; h=Content-Type:Content-Transfer-Encoding:Cc:Cc:Date:Date:From:From:In-Reply-To:List-Subscribe:List-Post:List-Id:List-Archive:List-Help:List-Unsubscribe:MIME-Version:Message-ID:References:Sender:Subject:Subject:To:To:Message-Id:Reply-To; bh=L2tag/flm2DnlVu97wBG0UtzJOMjy/ZOd5t20CFccvo=; b=Qrte0Hc7svZHhpiyIIIE5eTFk/RRCnHeR8XzL/bbATmdtlWpCHQSrijzcDvOr59LN/UXSK691miZJQ8TfIUoP57+WXt58c8aYDun0Jyaxe09knIUz+B10PkStVkA5aiLWCY9SjzPrsK2pLYyGN1MGFW8L7OekHv4f2H+3TX3tPc= ARC-Authentication-Results: i=1; mx.zohomail.com; dkim=pass; spf=pass (zohomail.com: domain of gnu.org designates 209.51.188.17 as permitted sender) smtp.mailfrom=qemu-devel-bounces+importer=patchew.org@nongnu.org; dmarc=pass header.from= (p=none dis=none) Return-Path: Received: from lists.gnu.org (lists.gnu.org [209.51.188.17]) by mx.zohomail.com with SMTPS id 1718043848812343.86822333065004; Mon, 10 Jun 2024 11:24:08 -0700 (PDT) Received: from localhost ([::1] helo=lists1p.gnu.org) by lists.gnu.org with esmtp (Exim 4.90_1) (envelope-from ) id 1sGjgG-0000WH-H7; Mon, 10 Jun 2024 14:23:44 -0400 Received: from eggs.gnu.org ([2001:470:142:3::10]) by lists.gnu.org with esmtps (TLS1.2:ECDHE_RSA_AES_256_GCM_SHA384:256) (Exim 4.90_1) (envelope-from ) id 1sGjg7-0000Sc-UT for qemu-devel@nongnu.org; Mon, 10 Jun 2024 14:23:38 -0400 Received: from mail-wm1-x32c.google.com ([2a00:1450:4864:20::32c]) by eggs.gnu.org with esmtps (TLS1.2:ECDHE_RSA_AES_128_GCM_SHA256:128) (Exim 4.90_1) (envelope-from ) id 1sGjfx-0006AD-Sw for qemu-devel@nongnu.org; Mon, 10 Jun 2024 14:23:35 -0400 Received: by mail-wm1-x32c.google.com with SMTP id 5b1f17b1804b1-42165f6645fso2376805e9.2 for ; Mon, 10 Jun 2024 11:23:24 -0700 (PDT) Received: from localhost.localdomain (adsl-33.37.6.162.tellas.gr. [37.6.162.33]) by smtp.gmail.com with ESMTPSA id 5b1f17b1804b1-42161147811sm135487395e9.18.2024.06.10.11.23.15 (version=TLS1_3 cipher=TLS_AES_256_GCM_SHA384 bits=256/256); Mon, 10 Jun 2024 11:23:20 -0700 (PDT) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=linaro.org; s=google; t=1718043803; x=1718648603; darn=nongnu.org; h=content-transfer-encoding:mime-version:references:in-reply-to :message-id:date:subject:cc:to:from:from:to:cc:subject:date :message-id:reply-to; bh=L2tag/flm2DnlVu97wBG0UtzJOMjy/ZOd5t20CFccvo=; b=SEaaIHBTfkc9CDkijfPPL7T0zaDO0hrvn9PTjWykWFDWzGw84HipIvSoxRxjdT7BF4 Z5dc7HSomYN1gxBEdwfTPK4WIF2Wx6eoYsM9I0PDmy/HHw1+ONmLNmBlq/LUWJeldAr+ op8nYC4xZORoKAg/SnonzoCqx62Gc1TQoa+gYhxR4EOqbV1r40FMv6b4R3vbkn/d7zv8 dZXoz39fOcZzf2PVkx4RzuywwukNHklhfMG/iiUAe8j1B7XEe+s+H+PnqWnfNZqaIILN frm+CegmjSa+DdHFbpJAySnQKPZ3+jh49jlYlsRz16/ossVyOoqRt87jw5c4wO/0hzDh FwOw== X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20230601; t=1718043803; x=1718648603; h=content-transfer-encoding:mime-version:references:in-reply-to :message-id:date:subject:cc:to:from:x-gm-message-state:from:to:cc :subject:date:message-id:reply-to; bh=L2tag/flm2DnlVu97wBG0UtzJOMjy/ZOd5t20CFccvo=; b=Wx5hAAEvwTkNmVxsRfx8QSPpgNSX1un5nZVDYY0MiTHXhK38nsXrOoLq59jaNb3MqN K9XFjDdebb3dImM+A1JQgCbAXcdgjOgUlbYvbl8CfO6wm+GJWANwx+UZlmUczxz+pX6p LEBGLAQC/2nBcHT9bqWFzfM43nwGPbwJ2y/wKLeTuQGSsot63iYF1iZdT6U5zzBbS1KX s3bPGW1KAcmtN8Nmlee6IoDeyGI3H9ODvg9PAF31IknhOiU9EK3zXGupyXvj7Uncizba WTcUN7DDH/047UjdtbE5wXKNZ1TFsBWHGpnd+07fnQBBx5wbUeB9TpWxZrIWPbs30Sfp 3qhg== X-Gm-Message-State: AOJu0Yz9plIoa1GO1MlNuCt/w+4Q7TOIAgFkjBn6W/1L8I5eORVbcR8l aUpy4pqKjAjWauFjey1MCdrUPDsaAonIfg50r2lGnk3YrHuAj9NljJmNBYran/Q6oRDKivB9C1W 1pZs= X-Google-Smtp-Source: AGHT+IHf0O6Xu2yqjYSeRpXT4vSh9pWoYHLqFLvi8CFR0aWw99ygZiBDjWdFBPkHjvai7NjTKPQQuA== X-Received: by 2002:a05:600c:1d24:b0:421:7c7d:bfda with SMTP id 5b1f17b1804b1-4217c7dc1b9mr54014725e9.34.1718043801163; Mon, 10 Jun 2024 11:23:21 -0700 (PDT) From: Manos Pitsidianakis To: qemu-devel@nongnu.org Cc: Stefan Hajnoczi , Mads Ynddal , Paolo Bonzini , Peter Maydell , =?UTF-8?q?Alex=20Benn=C3=A9e?= , =?UTF-8?q?Daniel=20P=2E=20Berrang=C3=A9?= , =?UTF-8?q?Marc-Andr=C3=A9=20Lureau?= , Thomas Huth , Markus Armbruster , =?UTF-8?q?Philippe=20Mathieu-Daud=C3=A9?= , Zhao Liu , Gustavo Romero , Pierrick Bouvier Subject: [RFC PATCH v1 2/6] rust: add PL011 device model Date: Mon, 10 Jun 2024 21:22:37 +0300 Message-ID: X-Mailer: git-send-email 2.44.0 In-Reply-To: References: MIME-Version: 1.0 Content-Transfer-Encoding: quoted-printable Received-SPF: pass (zohomail.com: domain of gnu.org designates 209.51.188.17 as permitted sender) client-ip=209.51.188.17; envelope-from=qemu-devel-bounces+importer=patchew.org@nongnu.org; helo=lists.gnu.org; Received-SPF: pass client-ip=2a00:1450:4864:20::32c; envelope-from=manos.pitsidianakis@linaro.org; helo=mail-wm1-x32c.google.com X-Spam_score_int: -20 X-Spam_score: -2.1 X-Spam_bar: -- X-Spam_report: (-2.1 / 5.0 requ) BAYES_00=-1.9, DKIM_SIGNED=0.1, DKIM_VALID=-0.1, DKIM_VALID_AU=-0.1, DKIM_VALID_EF=-0.1, RCVD_IN_DNSWL_NONE=-0.0001, SPF_HELO_NONE=0.001, SPF_PASS=-0.001, T_SCC_BODY_TEXT_LINE=-0.01 autolearn=ham autolearn_force=no X-Spam_action: no action X-BeenThere: qemu-devel@nongnu.org X-Mailman-Version: 2.1.29 Precedence: list List-Id: List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , Errors-To: qemu-devel-bounces+importer=patchew.org@nongnu.org Sender: qemu-devel-bounces+importer=patchew.org@nongnu.org X-ZohoMail-DKIM: pass (identity @linaro.org) X-ZM-MESSAGEID: 1718043852554100001 Content-Type: text/plain; charset="utf-8" Signed-off-by: Manos Pitsidianakis --- Make sure to also check out generated rustdoc at https://rust-for-qemu-epilys-aebb06ca9f9adfe6584811c14ae44156501d935ba4.git= lab.io/pl011/index.html --- meson.build | 18 + rust/meson.build | 65 + rust/pl011/.cargo/config.toml | 2 + rust/pl011/.gitignore | 1 + rust/pl011/Cargo.lock | 120 + rust/pl011/Cargo.toml | 26 + rust/pl011/README.md | 42 + rust/pl011/rustfmt.toml | 10 + rust/pl011/src/definitions.rs | 95 + rust/pl011/src/device.rs | 531 + rust/pl011/src/device_class.rs | 95 + rust/pl011/src/generated.rs | 55461 +++++++++++++++++++++++++++++++ rust/pl011/src/lib.rs | 575 + rust/pl011/src/memory_ops.rs | 38 + 14 files changed, 57079 insertions(+) create mode 100644 rust/meson.build create mode 100644 rust/pl011/.cargo/config.toml create mode 100644 rust/pl011/.gitignore create mode 100644 rust/pl011/Cargo.lock create mode 100644 rust/pl011/Cargo.toml create mode 100644 rust/pl011/README.md create mode 100644 rust/pl011/rustfmt.toml create mode 100644 rust/pl011/src/definitions.rs create mode 100644 rust/pl011/src/device.rs create mode 100644 rust/pl011/src/device_class.rs create mode 100644 rust/pl011/src/generated.rs create mode 100644 rust/pl011/src/lib.rs create mode 100644 rust/pl011/src/memory_ops.rs diff --git a/meson.build b/meson.build index 3533889852..b45b4cf00b 100644 --- a/meson.build +++ b/meson.build @@ -296,6 +296,10 @@ if get_option('with_rust').allowed() endif with_rust =3D cargo.found() =20 +if with_rust + subdir('rust') +endif + # default flags for all hosts # We use -fwrapv to tell the compiler that we require a C dialect where # left shift of signed integers is well defined and has the expected @@ -3654,6 +3658,20 @@ if enable_modules endforeach endif =20 +if with_rust + foreach target : target_dirs + if target.endswith('-softmmu') + config_target =3D config_target_mak[target] + arch =3D config_target['TARGET_NAME'] =3D=3D 'sparc64' ? 'sparc64' := config_target['TARGET_BASE_ARCH'] + if rust_targets.has_key(target) + foreach t: rust_targets[target] + hw_arch[arch].add(t) + endforeach + endif + endif + endforeach +endif + nm =3D find_program('nm') undefsym =3D find_program('scripts/undefsym.py') block_syms =3D custom_target('block.syms', output: 'block.syms', diff --git a/rust/meson.build b/rust/meson.build new file mode 100644 index 0000000000..05a859259b --- /dev/null +++ b/rust/meson.build @@ -0,0 +1,65 @@ +rust_targets =3D {} + +cargo_wrapper =3D [ + find_program(meson.source_root() / 'scripts/cargo_wrapper.py'), + '--config-headers', meson.project_build_root() / 'config-host.h', + '--meson-build-dir', meson.current_build_dir(), + '--meson-source-dir', meson.current_source_dir(), +] + +if get_option('b_colorout') !=3D 'never' + cargo_wrapper +=3D ['--color', 'always'] +endif + +if with_rust + rust_target_triple =3D get_option('with_rust_target_triple') + if meson.is_cross_build() + # more default target mappings may be added over time + if rust_target_triple =3D=3D '' and targetos =3D=3D 'windows' + rust_target_triple =3D host_machine.cpu() + '-pc-windows-gnu' + endif + if rust_target_triple =3D=3D '' + error('cross-compiling, but no Rust target-triple defined.') + endif + endif +endif + +if get_option('optimization') in ['0', '1', 'g'] + rs_build_type =3D 'debug' +else + rs_build_type =3D 'release' +endif + +_host_target_list =3D [['x86_64-unknown-linux-gnu', 'aarch64-softmmu']] + +foreach targets: _host_target_list + host_target =3D targets[0] + target =3D targets[1] + output =3D meson.current_build_dir() / host_target / rs_build_type / 'li= bpl011.a' + if rust_target_triple =3D=3D '' + rust_target_triple =3D host_target + endif + rust_pl011_cargo =3D custom_target('rust_pl011_cargo', + output: ['libpl011.a'], + build_always_stale: true, + depends: [], + command: [cargo_wrapper, + '--crate-dir', + meson.current_source_dir() / 'pl0= 11', + '--profile', + rs_build_type, + '--target-triple', + rust_target_triple, + '--outdir', + '@OUTDIR@', + 'build-lib' + ] + ) + rust_pl011 =3D declare_dependency(link_args : [ + '-Wl,--whole-archive', + output, + '-Wl,--no-whole-archive' + ], + sources: [rust_pl011_cargo]) + rust_targets +=3D { target: [rust_pl011] } +endforeach diff --git a/rust/pl011/.cargo/config.toml b/rust/pl011/.cargo/config.toml new file mode 100644 index 0000000000..241210ffa7 --- /dev/null +++ b/rust/pl011/.cargo/config.toml @@ -0,0 +1,2 @@ +[build] +rustflags =3D ["-Crelocation-model=3Dpic", "-Ctarget-feature=3D+crt-static= "] diff --git a/rust/pl011/.gitignore b/rust/pl011/.gitignore new file mode 100644 index 0000000000..eb5a316cbd --- /dev/null +++ b/rust/pl011/.gitignore @@ -0,0 +1 @@ +target diff --git a/rust/pl011/Cargo.lock b/rust/pl011/Cargo.lock new file mode 100644 index 0000000000..d0fa46f9f5 --- /dev/null +++ b/rust/pl011/Cargo.lock @@ -0,0 +1,120 @@ +# This file is automatically @generated by Cargo. +# It is not intended for manual editing. +version =3D 3 + +[[package]] +name =3D "arbitrary-int" +version =3D "1.2.7" +source =3D "registry+https://github.com/rust-lang/crates.io-index" +checksum =3D "c84fc003e338a6f69fbd4f7fe9f92b535ff13e9af8997f3b14b6ddff8b1d= f46d" + +[[package]] +name =3D "bilge" +version =3D "0.2.0" +source =3D "registry+https://github.com/rust-lang/crates.io-index" +checksum =3D "dc707ed8ebf81de5cd6c7f48f54b4c8621760926cdf35a57000747c512e6= 7b57" +dependencies =3D [ + "arbitrary-int", + "bilge-impl", +] + +[[package]] +name =3D "bilge-impl" +version =3D "0.2.0" +source =3D "registry+https://github.com/rust-lang/crates.io-index" +checksum =3D "feb11e002038ad243af39c2068c8a72bcf147acf05025dcdb916fcc000ad= b2d8" +dependencies =3D [ + "itertools", + "proc-macro-error", + "proc-macro2", + "quote", + "syn", +] + +[[package]] +name =3D "either" +version =3D "1.12.0" +source =3D "registry+https://github.com/rust-lang/crates.io-index" +checksum =3D "3dca9240753cf90908d7e4aac30f630662b02aebaa1b58a3cadabdb23385= b58b" + +[[package]] +name =3D "itertools" +version =3D "0.11.0" +source =3D "registry+https://github.com/rust-lang/crates.io-index" +checksum =3D "b1c173a5686ce8bfa551b3563d0c2170bf24ca44da99c7ca4bfdab5418c3= fe57" +dependencies =3D [ + "either", +] + +[[package]] +name =3D "pl011" +version =3D "0.1.0" +dependencies =3D [ + "arbitrary-int", + "bilge", + "bilge-impl", +] + +[[package]] +name =3D "proc-macro-error" +version =3D "1.0.4" +source =3D "registry+https://github.com/rust-lang/crates.io-index" +checksum =3D "da25490ff9892aab3fcf7c36f08cfb902dd3e71ca0f9f9517bea02a73a5c= e38c" +dependencies =3D [ + "proc-macro-error-attr", + "proc-macro2", + "quote", + "version_check", +] + +[[package]] +name =3D "proc-macro-error-attr" +version =3D "1.0.4" +source =3D "registry+https://github.com/rust-lang/crates.io-index" +checksum =3D "a1be40180e52ecc98ad80b184934baf3d0d29f979574e439af5a55274b35= f869" +dependencies =3D [ + "proc-macro2", + "quote", + "version_check", +] + +[[package]] +name =3D "proc-macro2" +version =3D "1.0.84" +source =3D "registry+https://github.com/rust-lang/crates.io-index" +checksum =3D "ec96c6a92621310b51366f1e28d05ef11489516e93be030060e5fc12024a= 49d6" +dependencies =3D [ + "unicode-ident", +] + +[[package]] +name =3D "quote" +version =3D "1.0.36" +source =3D "registry+https://github.com/rust-lang/crates.io-index" +checksum =3D "0fa76aaf39101c457836aec0ce2316dbdc3ab723cdda1c6bd4e6ad4208ac= aca7" +dependencies =3D [ + "proc-macro2", +] + +[[package]] +name =3D "syn" +version =3D "2.0.66" +source =3D "registry+https://github.com/rust-lang/crates.io-index" +checksum =3D "c42f3f41a2de00b01c0aaad383c5a45241efc8b2d1eda5661812fda5f3cd= cff5" +dependencies =3D [ + "proc-macro2", + "quote", + "unicode-ident", +] + +[[package]] +name =3D "unicode-ident" +version =3D "1.0.12" +source =3D "registry+https://github.com/rust-lang/crates.io-index" +checksum =3D "3354b9ac3fae1ff6755cb6db53683adb661634f67557942dea4facebec0f= ee4b" + +[[package]] +name =3D "version_check" +version =3D "0.9.4" +source =3D "registry+https://github.com/rust-lang/crates.io-index" +checksum =3D "49874b5167b65d7193b8aba1567f5c7d93d001cafc34600cee003eda787e= 483f" diff --git a/rust/pl011/Cargo.toml b/rust/pl011/Cargo.toml new file mode 100644 index 0000000000..c150c0d917 --- /dev/null +++ b/rust/pl011/Cargo.toml @@ -0,0 +1,26 @@ +[package] +name =3D "pl011" +version =3D "0.1.0" +edition =3D "2021" +authors =3D ["Manos Pitsidianakis "] +license =3D "GPL-2.0 OR GPL-3.0-or-later" +readme =3D "README.md" +homepage =3D "https://meli-email.org" +description =3D "pl011 device model for QEMU" +repository =3D "https://gitlab.com/epilys/rust-for-qemu" +resolver =3D "2" +#keywords =3D [] +#categories =3D [] + +[lib] +crate-type =3D ["staticlib"] + +[dependencies] +arbitrary-int =3D "*" +bilge =3D "0.2.0" + +# bilge deps included here to include them with docs +bilge-impl =3D "0.2.0" + +# Do not include in global workspace +[workspace] diff --git a/rust/pl011/README.md b/rust/pl011/README.md new file mode 100644 index 0000000000..e732563d52 --- /dev/null +++ b/rust/pl011/README.md @@ -0,0 +1,42 @@ +# PL011 QEMU Device Model + +This library implements a device model for the PrimeCell=C2=AE UART (PL011) +device in QEMU. + +The C bindings were generated for commit `01782d6b29`: + +```console +$ git describe 01782d6b29 +v9.0.0-769-g01782d6b29 +``` + +with `bindgen`, using this build target: + +```console +$ ninja generated.rs +``` + +## Build static lib + +```sh +cargo build --target x86_64-unknown-linux-gnu +``` + +Replace host target triplet if necessary. + +## Generate Rust documentation + +To generate docs for this crate, including private items: + +```sh +cargo doc --no-deps --document-private-items --target x86_64-unknown-linux= -gnu +``` + +To include direct dependencies like `bilge` (bitmaps for register types): + +```sh +cargo tree --depth 1 -e normal --prefix none \ + | cut -d' ' -f1 \ + | xargs printf -- '-p %s\n' \ + | xargs cargo doc --no-deps --document-private-items --target x86_64-unkn= own-linux-gnu +``` diff --git a/rust/pl011/rustfmt.toml b/rust/pl011/rustfmt.toml new file mode 100644 index 0000000000..1d19067bad --- /dev/null +++ b/rust/pl011/rustfmt.toml @@ -0,0 +1,10 @@ +ignore =3D [ + "src/generated.rs" +] +edition =3D "2018" +format_generated_files =3D false +format_code_in_doc_comments =3D true +format_strings =3D true +imports_granularity =3D "Crate" +group_imports =3D "StdExternalCrate" +wrap_comments =3D true diff --git a/rust/pl011/src/definitions.rs b/rust/pl011/src/definitions.rs new file mode 100644 index 0000000000..f02604c114 --- /dev/null +++ b/rust/pl011/src/definitions.rs @@ -0,0 +1,95 @@ +//! Definitions required by QEMU when registering the device. + +use core::{ffi::CStr, mem::MaybeUninit, ptr::NonNull}; + +use crate::{device::PL011State, device_class::pl011_class_init, generated:= :*}; + +pub const TYPE_PL011: &CStr =3D unsafe { CStr::from_bytes_with_nul_uncheck= ed(b"x-pl011-rust\0") }; + +pub const PL011_ARM_INFO: TypeInfo =3D TypeInfo { + name: TYPE_PL011.as_ptr(), + parent: TYPE_SYS_BUS_DEVICE.as_ptr(), + instance_size: core::mem::size_of::(), + instance_align: core::mem::align_of::(), + instance_init: Some(pl011_init), + instance_post_init: None, + instance_finalize: None, + abstract_: false, + class_size: 0, + class_init: Some(pl011_class_init), + class_base_init: None, + class_data: core::ptr::null_mut(), + interfaces: core::ptr::null_mut(), +}; + +pub const VMSTATE_PL011: VMStateDescription =3D VMStateDescription { + name: PL011_ARM_INFO.name, + unmigratable: true, + ..unsafe { MaybeUninit::::zeroed().assume_init() } +}; +//version_id : 2, +//minimum_version_id : 2, +//post_load : pl011_post_load, +//fields =3D (const VMStateField[]) { +// VMSTATE_UINT32(readbuff, PL011State), +// VMSTATE_UINT32(flags, PL011State), +// VMSTATE_UINT32(lcr, PL011State), +// VMSTATE_UINT32(rsr, PL011State), +// VMSTATE_UINT32(cr, PL011State), +// VMSTATE_UINT32(dmacr, PL011State), +// VMSTATE_UINT32(int_enabled, PL011State), +// VMSTATE_UINT32(int_level, PL011State), +// VMSTATE_UINT32_ARRAY(read_fifo, PL011State, PL011_FIFO_DEPTH), +// VMSTATE_UINT32(ilpr, PL011State), +// VMSTATE_UINT32(ibrd, PL011State), +// VMSTATE_UINT32(fbrd, PL011State), +// VMSTATE_UINT32(ifl, PL011State), +// VMSTATE_INT32(read_pos, PL011State), +// VMSTATE_INT32(read_count, PL011State), +// VMSTATE_INT32(read_trigger, PL011State), +// VMSTATE_END_OF_LIST() +//}, +//.subsections =3D (const VMStateDescription * const []) { +// &vmstate_pl011_clock, +// NULL +//} + +#[no_mangle] +pub unsafe extern "C" fn pl011_init(obj: *mut Object) { + assert!(!obj.is_null()); + let mut state =3D NonNull::new_unchecked(obj.cast::()); + state.as_mut().init(); +} + +use crate::generated::module_init_type_MODULE_INIT_QOM; + +#[macro_export] +macro_rules! module_init { + ($func:expr, $type:expr) =3D> { + #[cfg_attr(target_os =3D "linux", link_section =3D ".ctors")] + #[cfg_attr(target_os =3D "macos", link_section =3D "__DATA,__mod_i= nit_func")] + #[cfg_attr(target_os =3D "windows", link_section =3D ".CRT$XCU")] + pub static LOAD_MODULE: extern "C" fn() =3D { + assert!($type < $crate::generated::module_init_type_MODULE_INI= T_MAX); + + extern "C" fn __load() { + // ::std::panic::set_hook(::std::boxed::Box::new(|_| {})); + + unsafe { + $crate::generated::register_module_init(Some($func), $= type); + } + } + + __load + }; + }; +} + +#[no_mangle] +unsafe extern "C" fn register_type() { + crate::generated::type_register_static(&PL011_ARM_INFO); +} + +module_init! { + register_type, module_init_type_MODULE_INIT_QOM +} diff --git a/rust/pl011/src/device.rs b/rust/pl011/src/device.rs new file mode 100644 index 0000000000..976ad2e4d6 --- /dev/null +++ b/rust/pl011/src/device.rs @@ -0,0 +1,531 @@ +use core::{ + ffi::{c_int, c_uchar, c_uint, c_void, CStr}, + mem::MaybeUninit, + ptr::{addr_of, addr_of_mut, NonNull}, +}; + +use crate::{ + definitions::PL011_ARM_INFO, + generated::{self, *}, + memory_ops::PL011_OPS, + registers::{self, Interrupt}, + RegisterOffset, +}; + +static PL011_ID_ARM: [c_uchar; 8] =3D [0x11, 0x10, 0x14, 0x00, 0x0d, 0xf0,= 0x05, 0xb1]; + +const DATA_BREAK: u32 =3D 1 << 10; + +/// QEMU sourced constant. +pub const PL011_FIFO_DEPTH: usize =3D 16_usize; + +#[repr(C)] +#[derive(Debug)] +/// PL011 Device Model in QEMU +pub struct PL011State { + pub parent_obj: SysBusDevice, + pub iomem: MemoryRegion, + pub readbuff: u32, + #[doc(alias =3D "fr")] + pub flags: registers::Flags, + #[doc(alias =3D "lcr")] + pub line_control: registers::LineControl, + #[doc(alias =3D "rsr")] + pub receive_status_error_clear: registers::ReceiveStatusErrorClear, + #[doc(alias =3D "cr")] + pub control: registers::Control, + pub dmacr: u32, + pub int_enabled: u32, + pub int_level: u32, + pub read_fifo: [u32; PL011_FIFO_DEPTH], + pub ilpr: u32, + pub ibrd: u32, + pub fbrd: u32, + pub ifl: u32, + pub read_pos: usize, + pub read_count: usize, + pub read_trigger: usize, + #[doc(alias =3D "chr")] + pub char_backend: CharBackend, + /// QEMU interrupts + /// + /// ```text + /// * sysbus MMIO region 0: device registers + /// * sysbus IRQ 0: `UARTINTR` (combined interrupt line) + /// * sysbus IRQ 1: `UARTRXINTR` (receive FIFO interrupt line) + /// * sysbus IRQ 2: `UARTTXINTR` (transmit FIFO interrupt line) + /// * sysbus IRQ 3: `UARTRTINTR` (receive timeout interrupt line) + /// * sysbus IRQ 4: `UARTMSINTR` (momem status interrupt line) + /// * sysbus IRQ 5: `UARTEINTR` (error interrupt line) + /// ``` + #[doc(alias =3D "irq")] + pub interrupts: [qemu_irq; 6usize], + #[doc(alias =3D "clk")] + pub clock: NonNull, + #[doc(alias =3D "migrate_clk")] + pub migrate_clock: bool, +} + +impl PL011State { + pub fn init(&mut self) { + unsafe { + memory_region_init_io( + addr_of_mut!(self.iomem), + addr_of_mut!(*self).cast::(), + &PL011_OPS, + addr_of_mut!(*self).cast::(), + PL011_ARM_INFO.name, + 0x1000, + ); + let sbd =3D addr_of_mut!(*self).cast::(); + let dev =3D addr_of_mut!(*self).cast::(); + sysbus_init_mmio(sbd, addr_of_mut!(self.iomem)); + for irq in self.interrupts.iter_mut() { + sysbus_init_irq(sbd, irq); + } + const CLK_NAME: &CStr =3D unsafe { CStr::from_bytes_with_nul_u= nchecked(b"clk\0") }; + self.clock =3D NonNull::new(qdev_init_clock_in( + dev, + CLK_NAME.as_ptr(), + None, /* pl011_clock_update */ + addr_of_mut!(*self).cast::(), + ClockEvent_ClockUpdate, + )) + .unwrap(); + } + } + + pub fn read(&mut self, offset: hwaddr, _size: core::ffi::c_uint) -> u6= 4 { + use RegisterOffset::*; + + match RegisterOffset::try_from(offset) { + Err(v) if (0x3f8..0x400).contains(&v) =3D> { + u64::from(PL011_ID_ARM[((offset - 0xfe0) >> 2) as usize]) + } + Err(_) =3D> { + // qemu_log_mask(LOG_GUEST_ERROR, "pl011_read: Bad offset = 0x%x\n", (int)offset); + 0 + } + Ok(DR) =3D> { + // s->flags &=3D ~PL011_FLAG_RXFF; + self.flags.set_receive_fifo_full(false); + let c =3D self.read_fifo[self.read_pos]; + if self.read_count > 0 { + self.read_count -=3D 1; + self.read_pos =3D (self.read_pos + 1) & (self.fifo_dep= th() - 1); + } + if self.read_count =3D=3D 0 { + // self.flags |=3D PL011_FLAG_RXFE; + self.flags.set_receive_fifo_empty(true); + } + if self.read_count + 1 =3D=3D self.read_trigger { + //self.int_level &=3D ~ INT_RX; + self.int_level &=3D !registers::INT_RX; + } + // Update error bits. + self.receive_status_error_clear =3D c.to_be_bytes()[3].int= o(); + self.update(); + unsafe { qemu_chr_fe_accept_input(&mut self.char_backend) = }; + c.into() + } + Ok(RSR) =3D> u8::from(self.receive_status_error_clear).into(), + Ok(FR) =3D> u16::from(self.flags).into(), + Ok(FBRD) =3D> self.fbrd.into(), + Ok(ILPR) =3D> self.ilpr.into(), + Ok(IBRD) =3D> self.ibrd.into(), + Ok(LCR_H) =3D> u16::from(self.line_control).into(), + Ok(CR) =3D> { + // We exercise our self-control. + u16::from(self.control).into() + } + Ok(FLS) =3D> self.ifl.into(), + Ok(IMSC) =3D> self.int_enabled.into(), + Ok(RIS) =3D> self.int_level.into(), + Ok(MIS) =3D> u64::from(self.int_level & self.int_enabled), + Ok(ICR) =3D> { + // "The UARTICR Register is the interrupt clear register a= nd is write-only" + // Source: ARM DDI 0183G 3.3.13 Interrupt Clear Register, = UARTICR + 0 + } + Ok(DMACR) =3D> self.dmacr.into(), + } + } + + pub fn write(&mut self, offset: hwaddr, value: u64) { + // eprintln!("write offset {offset} value {value}"); + use RegisterOffset::*; + let value: u32 =3D value as u32; + match RegisterOffset::try_from(offset) { + Err(_bad_offset) =3D> { + eprintln!("write bad offset {offset} value {value}"); + } + Ok(DR) =3D> { + // ??? Check if transmitter is enabled. + let ch: u8 =3D value as u8; + // XXX this blocks entire thread. Rewrite to use + // qemu_chr_fe_write and background I/O callbacks + unsafe { + qemu_chr_fe_write_all(addr_of_mut!(self.char_backend),= &ch, 1); + } + self.loopback_tx(value); + self.int_level |=3D registers::INT_TX; + self.update(); + } + Ok(RSR) =3D> { + self.receive_status_error_clear =3D 0.into(); + } + Ok(FR) =3D> { + // flag writes are ignored + } + Ok(ILPR) =3D> { + self.ilpr =3D value; + } + Ok(IBRD) =3D> { + self.ibrd =3D value; + } + Ok(FBRD) =3D> { + self.fbrd =3D value; + } + Ok(LCR_H) =3D> { + let value =3D value as u16; + let new_val: registers::LineControl =3D value.into(); + // Reset the FIFO state on FIFO enable or disable + if bool::from(self.line_control.fifos_enabled()) + ^ bool::from(new_val.fifos_enabled()) + { + self.reset_fifo(); + } + if self.line_control.send_break() ^ new_val.send_break() { + let mut break_enable: c_int =3D new_val.send_break().i= nto(); + unsafe { + qemu_chr_fe_ioctl( + addr_of_mut!(self.char_backend), + CHR_IOCTL_SERIAL_SET_BREAK as i32, + addr_of_mut!(break_enable).cast::(), + ); + } + self.loopback_break(break_enable > 0); + } + self.line_control =3D new_val; + self.set_read_trigger(); + } + Ok(CR) =3D> { + // ??? Need to implement the enable bit. + let value =3D value as u16; + self.control =3D value.into(); + self.loopback_mdmctrl(); + } + Ok(FLS) =3D> { + self.ifl =3D value; + self.set_read_trigger(); + } + Ok(IMSC) =3D> { + self.int_enabled =3D value; + self.update(); + } + Ok(RIS) =3D> {} + Ok(MIS) =3D> {} + Ok(ICR) =3D> { + self.int_level &=3D !value; + self.update(); + } + Ok(DMACR) =3D> { + self.dmacr =3D value; + if value & 3 > 0 { + // qemu_log_mask(LOG_UNIMP, "pl011: DMA not implemente= d\n"); + eprintln!("pl011: DMA not implemented"); + } + } + } + } + + #[inline] + fn loopback_tx(&mut self, value: u32) { + if !self.loopback_enabled() { + return; + } + + // Caveat: + // + // In real hardware, TX loopback happens at the serial-bit level + // and then reassembled by the RX logics back into bytes and placed + // into the RX fifo. That is, loopback happens after TX fifo. + // + // Because the real hardware TX fifo is time-drained at the frame + // rate governed by the configured serial format, some loopback + // bytes in TX fifo may still be able to get into the RX fifo + // that could be full at times while being drained at software + // pace. + // + // In such scenario, the RX draining pace is the major factor + // deciding which loopback bytes get into the RX fifo, unless + // hardware flow-control is enabled. + // + // For simplicity, the above described is not emulated. + self.put_fifo(value); + } + + fn loopback_mdmctrl(&mut self) { + if !self.loopback_enabled() { + return; + } + + /* + * Loopback software-driven modem control outputs to modem status = inputs: + * FR.RI <=3D CR.Out2 + * FR.DCD <=3D CR.Out1 + * FR.CTS <=3D CR.RTS + * FR.DSR <=3D CR.DTR + * + * The loopback happens immediately even if this call is triggered + * by setting only CR.LBE. + * + * CTS/RTS updates due to enabled hardware flow controls are not + * dealt with here. + */ + + //fr =3D s->flags & ~(PL011_FLAG_RI | PL011_FLAG_DCD | + // PL011_FLAG_DSR | PL011_FLAG_CTS); + //fr |=3D (cr & CR_OUT2) ? PL011_FLAG_RI : 0; + //fr |=3D (cr & CR_OUT1) ? PL011_FLAG_DCD : 0; + //fr |=3D (cr & CR_RTS) ? PL011_FLAG_CTS : 0; + //fr |=3D (cr & CR_DTR) ? PL011_FLAG_DSR : 0; + // + self.flags.set_ring_indicator(self.control.out_2()); + self.flags.set_data_carrier_detect(self.control.out_1()); + self.flags.set_clear_to_send(self.control.request_to_send()); + self.flags + .set_data_set_ready(self.control.data_transmit_ready()); + + // Change interrupts based on updated FR + let mut il =3D self.int_level; + + il &=3D !Interrupt::MS; + //il |=3D (fr & PL011_FLAG_DSR) ? INT_DSR : 0; + //il |=3D (fr & PL011_FLAG_DCD) ? INT_DCD : 0; + //il |=3D (fr & PL011_FLAG_CTS) ? INT_CTS : 0; + //il |=3D (fr & PL011_FLAG_RI) ? INT_RI : 0; + + if self.flags.data_set_ready() { + il |=3D Interrupt::DSR as u32; + } + if self.flags.data_carrier_detect() { + il |=3D Interrupt::DCD as u32; + } + if self.flags.clear_to_send() { + il |=3D Interrupt::CTS as u32; + } + if self.flags.ring_indicator() { + il |=3D Interrupt::RI as u32; + } + self.int_level =3D il; + self.update(); + } + + fn loopback_break(&mut self, enable: bool) { + if enable { + self.loopback_tx(DATA_BREAK); + } + } + + fn set_read_trigger(&mut self) { + //#if 0 + // /* The docs say the RX interrupt is triggered when the FIFO = exceeds + // the threshold. However linux only reads the FIFO in resp= onse to an + // interrupt. Triggering the interrupt when the FIFO is non= -empty seems + // to make things work. */ + // if (s->lcr & LCR_FEN) + // s->read_trigger =3D (s->ifl >> 1) & 0x1c; + // else + //#endif + self.read_trigger =3D 1; + } + + pub fn realize(&mut self) { + unsafe { + qemu_chr_fe_set_handlers( + addr_of_mut!(self.char_backend), + Some(pl011_can_receive), + Some(pl011_receive), + Some(pl011_event), + None, + addr_of_mut!(*self).cast::(), + core::ptr::null_mut(), + true, + ); + } + } + + pub fn reset(&mut self) { + self.line_control.reset(); + self.receive_status_error_clear.reset(); + self.dmacr =3D 0; + self.int_enabled =3D 0; + self.int_level =3D 0; + self.ilpr =3D 0; + self.ibrd =3D 0; + self.fbrd =3D 0; + self.read_trigger =3D 1; + self.ifl =3D 0x12; + self.control.reset(); + self.flags =3D 0.into(); + self.reset_fifo(); + } + + pub fn reset_fifo(&mut self) { + self.read_count =3D 0; + self.read_pos =3D 0; + + /* Reset FIFO flags */ + self.flags.reset(); + } + + pub fn can_receive(&self) -> bool { + // trace_pl011_can_receive(s->lcr, s->read_count, r); + self.read_count < self.fifo_depth() + } + + pub fn event(&mut self, event: QEMUChrEvent) { + if event =3D=3D generated::QEMUChrEvent_CHR_EVENT_BREAK && !self.f= ifo_enabled() { + self.put_fifo(DATA_BREAK); + self.receive_status_error_clear.set_break_error(true); + } + } + + #[inline] + pub fn fifo_enabled(&self) -> bool { + matches!(self.line_control.fifos_enabled(), registers::Mode::FIFO) + } + + #[inline] + pub fn loopback_enabled(&self) -> bool { + self.control.enable_loopback() + } + + #[inline] + pub fn fifo_depth(&self) -> usize { + // Note: FIFO depth is expected to be power-of-2 + if self.fifo_enabled() { + return PL011_FIFO_DEPTH; + } + 1 + } + + pub fn put_fifo(&mut self, value: c_uint) { + let depth =3D self.fifo_depth(); + assert!(depth > 0); + let slot =3D (self.read_pos + self.read_count) & (depth - 1); + self.read_fifo[slot] =3D value; + self.read_count +=3D 1; + // s->flags &=3D ~PL011_FLAG_RXFE; + self.flags.set_receive_fifo_empty(false); + if self.read_count =3D=3D depth { + //s->flags |=3D PL011_FLAG_RXFF; + self.flags.set_receive_fifo_full(true); + } + + if self.read_count =3D=3D self.read_trigger { + self.int_level |=3D registers::INT_RX; + self.update(); + } + } + + pub fn update(&mut self) { + let flags =3D self.int_level & self.int_enabled; + for (irq, i) in self.interrupts.iter().zip(IRQMASK) { + unsafe { qemu_set_irq(*irq, ((flags & i) !=3D 0) as u32 as c_i= nt) }; + } + } +} + +/// Which bits in the interrupt status matter for each outbound IRQ line ? +pub const IRQMASK: [u32; 6] =3D [ + /* combined IRQ */ + Interrupt::E + | Interrupt::MS + | Interrupt::RT as u32 + | Interrupt::TX as u32 + | Interrupt::RX as u32, + Interrupt::RX as u32, + Interrupt::TX as u32, + Interrupt::RT as u32, + Interrupt::MS, + Interrupt::E, +]; + +pub unsafe extern "C" fn pl011_can_receive(opaque: *mut c_void) -> c_int { + assert!(!opaque.is_null()); + let state =3D NonNull::new_unchecked(opaque.cast::()); + state.as_ref().can_receive().into() +} +pub unsafe extern "C" fn pl011_receive( + opaque: *mut core::ffi::c_void, + buf: *const u8, + size: core::ffi::c_int, +) { + assert!(!opaque.is_null()); + let mut state =3D NonNull::new_unchecked(opaque.cast::()); + if state.as_ref().loopback_enabled() { + return; + } + if size > 0 { + assert!(!buf.is_null()); + state.as_mut().put_fifo(*buf.cast::()) + } +} + +pub unsafe extern "C" fn pl011_event(opaque: *mut core::ffi::c_void, event= : QEMUChrEvent) { + assert!(!opaque.is_null()); + let mut state =3D NonNull::new_unchecked(opaque.cast::()); + state.as_mut().event(event) +} + +pub const VMSTATE_PL011: VMStateDescription =3D VMStateDescription { + name: PL011_ARM_INFO.name, + unmigratable: true, + ..unsafe { MaybeUninit::::zeroed().assume_init() } +}; +//version_id : 2, +//minimum_version_id : 2, +//post_load : pl011_post_load, +//fields =3D (const VMStateField[]) { +// VMSTATE_UINT32(readbuff, PL011State), +// VMSTATE_UINT32(flags, PL011State), +// VMSTATE_UINT32(lcr, PL011State), +// VMSTATE_UINT32(rsr, PL011State), +// VMSTATE_UINT32(cr, PL011State), +// VMSTATE_UINT32(dmacr, PL011State), +// VMSTATE_UINT32(int_enabled, PL011State), +// VMSTATE_UINT32(int_level, PL011State), +// VMSTATE_UINT32_ARRAY(read_fifo, PL011State, PL011_FIFO_DEPTH), +// VMSTATE_UINT32(ilpr, PL011State), +// VMSTATE_UINT32(ibrd, PL011State), +// VMSTATE_UINT32(fbrd, PL011State), +// VMSTATE_UINT32(ifl, PL011State), +// VMSTATE_INT32(read_pos, PL011State), +// VMSTATE_INT32(read_count, PL011State), +// VMSTATE_INT32(read_trigger, PL011State), +// VMSTATE_END_OF_LIST() +//}, +//.subsections =3D (const VMStateDescription * const []) { +// &vmstate_pl011_clock, +// NULL +//} + +pub unsafe extern "C" fn pl011_create( + addr: u64, + irq: qemu_irq, + chr: *mut Chardev, +) -> *mut DeviceState { + let dev: *mut DeviceState =3D unsafe { qdev_new(PL011_ARM_INFO.name) }; + assert!(!dev.is_null()); + let sysbus: *mut SysBusDevice =3D dev as *mut SysBusDevice; + + unsafe { + qdev_prop_set_chr(dev, generated::TYPE_CHARDEV.as_ptr(), chr); + sysbus_realize_and_unref(sysbus, addr_of!(error_fatal) as *mut *mu= t Error); + sysbus_mmio_map(sysbus, 0, addr); + sysbus_connect_irq(sysbus, 0, irq); + } + dev +} diff --git a/rust/pl011/src/device_class.rs b/rust/pl011/src/device_class.rs new file mode 100644 index 0000000000..50d91eb527 --- /dev/null +++ b/rust/pl011/src/device_class.rs @@ -0,0 +1,95 @@ +use core::{mem::MaybeUninit, ptr::NonNull}; +use std::sync::OnceLock; + +use crate::{ + device::{PL011State, VMSTATE_PL011}, + generated::*, +}; + +#[no_mangle] +pub unsafe extern "C" fn pl011_class_init(klass: *mut ObjectClass, _: *mut= core::ffi::c_void) { + let mut dc =3D NonNull::new(klass.cast::()).unwrap(); + dc.as_mut().realize =3D Some(pl011_realize); + dc.as_mut().reset =3D Some(pl011_reset); + dc.as_mut().vmsd =3D &VMSTATE_PL011; + _ =3D PL011_PROPERTIES.get_or_init(make_pl011_properties); + device_class_set_props( + dc.as_mut(), + PL011_PROPERTIES.get_mut().unwrap().as_mut_ptr(), + ); +} + +#[macro_export] +macro_rules! define_property { + ($name:expr, $state:ty, $field:expr, $prop:expr, $type:expr, default = =3D $defval:expr) =3D> { + $crate::generated::Property { + name: $name, + info: $prop, + offset: ::core::mem::offset_of!($state, $field) as _, + bitnr: 0, + bitmask: 0, + set_default: true, + defval: $crate::generated::Property__bindgen_ty_1 { u: $defval= .into() }, + arrayoffset: 0, + arrayinfo: ::core::ptr::null(), + arrayfieldsize: 0, + link_type: ::core::ptr::null(), + } + }; + ($name:expr, $state:ty, $field:expr, $prop:expr, $type:expr) =3D> { + $crate::generated::Property { + name: $name, + info: $prop, + offset: ::core::mem::offset_of!($state, $field) as _, + bitnr: 0, + bitmask: 0, + set_default: false, + defval: $crate::generated::Property__bindgen_ty_1 { i: 0 }, + arrayoffset: 0, + arrayinfo: ::core::ptr::null(), + arrayfieldsize: 0, + link_type: ::core::ptr::null(), + } + }; +} + +#[no_mangle] +pub static mut PL011_PROPERTIES: OnceLock<[Property; 3]> =3D OnceLock::new= (); + +unsafe impl Send for Property {} +unsafe impl Sync for Property {} + +#[no_mangle] +fn make_pl011_properties() -> [Property; 3] { + [ + define_property!( + c"chardev".as_ptr(), + PL011State, + char_backend, + unsafe { &qdev_prop_chr }, + CharBackend + ), + define_property!( + c"migrate-clk".as_ptr(), + PL011State, + migrate_clock, + unsafe { &qdev_prop_bool }, + bool + ), + unsafe { MaybeUninit::::zeroed().assume_init() }, + ] +} + +#[no_mangle] +pub unsafe extern "C" fn pl011_realize(dev: *mut DeviceState, _errp: *mut = *mut Error) { + assert!(!dev.is_null()); + let mut state =3D NonNull::new_unchecked(dev.cast::()); + state.as_mut().realize(); +} + +#[no_mangle] +pub unsafe extern "C" fn pl011_reset(dev: *mut DeviceState) { + assert!(!dev.is_null()); + let mut state =3D NonNull::new_unchecked(dev.cast::()); + state.as_mut().reset(); +} diff --git a/rust/pl011/src/generated.rs b/rust/pl011/src/generated.rs new file mode 100644 index 0000000000..8ce6b032d1 --- /dev/null +++ b/rust/pl011/src/generated.rs @@ -0,0 +1,55461 @@ +/* automatically generated by rust-bindgen 0.69.4 */ + +#[repr(C)] +#[derive(Copy, Clone, Debug, Default, Eq, Hash, Ord, PartialEq, PartialOrd= )] +pub struct __BindgenBitfieldUnit { + storage: Storage, +} +impl __BindgenBitfieldUnit { + #[inline] + pub const fn new(storage: Storage) -> Self { + Self { storage } + } +} +impl __BindgenBitfieldUnit +where + Storage: AsRef<[u8]> + AsMut<[u8]>, +{ + #[inline] + pub fn get_bit(&self, index: usize) -> bool { + debug_assert!(index / 8 < self.storage.as_ref().len()); + let byte_index =3D index / 8; + let byte =3D self.storage.as_ref()[byte_index]; + let bit_index =3D if cfg!(target_endian =3D "big") { + 7 - (index % 8) + } else { + index % 8 + }; + let mask =3D 1 << bit_index; + byte & mask =3D=3D mask + } + #[inline] + pub fn set_bit(&mut self, index: usize, val: bool) { + debug_assert!(index / 8 < self.storage.as_ref().len()); + let byte_index =3D index / 8; + let byte =3D &mut self.storage.as_mut()[byte_index]; + let bit_index =3D if cfg!(target_endian =3D "big") { + 7 - (index % 8) + } else { + index % 8 + }; + let mask =3D 1 << bit_index; + if val { + *byte |=3D mask; + } else { + *byte &=3D !mask; + } + } + #[inline] + pub fn get(&self, bit_offset: usize, bit_width: u8) -> u64 { + debug_assert!(bit_width <=3D 64); + debug_assert!(bit_offset / 8 < self.storage.as_ref().len()); + debug_assert!((bit_offset + (bit_width as usize)) / 8 <=3D self.st= orage.as_ref().len()); + let mut val =3D 0; + for i in 0..(bit_width as usize) { + if self.get_bit(i + bit_offset) { + let index =3D if cfg!(target_endian =3D "big") { + bit_width as usize - 1 - i + } else { + i + }; + val |=3D 1 << index; + } + } + val + } + #[inline] + pub fn set(&mut self, bit_offset: usize, bit_width: u8, val: u64) { + debug_assert!(bit_width <=3D 64); + debug_assert!(bit_offset / 8 < self.storage.as_ref().len()); + debug_assert!((bit_offset + (bit_width as usize)) / 8 <=3D self.st= orage.as_ref().len()); + for i in 0..(bit_width as usize) { + let mask =3D 1 << i; + let val_bit_is_set =3D val & mask =3D=3D mask; + let index =3D if cfg!(target_endian =3D "big") { + bit_width as usize - 1 - i + } else { + i + }; + self.set_bit(index + bit_offset, val_bit_is_set); + } + } +} +#[repr(C)] +#[derive(Default)] +pub struct __IncompleteArrayField(::core::marker::PhantomData, [T; 0= ]); +impl __IncompleteArrayField { + #[inline] + pub const fn new() -> Self { + __IncompleteArrayField(::core::marker::PhantomData, []) + } + #[inline] + pub fn as_ptr(&self) -> *const T { + self as *const _ as *const T + } + #[inline] + pub fn as_mut_ptr(&mut self) -> *mut T { + self as *mut _ as *mut T + } + #[inline] + pub unsafe fn as_slice(&self, len: usize) -> &[T] { + ::core::slice::from_raw_parts(self.as_ptr(), len) + } + #[inline] + pub unsafe fn as_mut_slice(&mut self, len: usize) -> &mut [T] { + ::core::slice::from_raw_parts_mut(self.as_mut_ptr(), len) + } +} +impl ::core::fmt::Debug for __IncompleteArrayField { + fn fmt(&self, fmt: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Re= sult { + fmt.write_str("__IncompleteArrayField") + } +} +#[allow(unsafe_code)] +pub const CONFIG_BINDIR: &::core::ffi::CStr =3D + unsafe { ::core::ffi::CStr::from_bytes_with_nul_unchecked(b"/usr/local= /bin\0") }; +#[allow(unsafe_code)] +pub const CONFIG_HOST_DSOSUF: &::core::ffi::CStr =3D + unsafe { ::core::ffi::CStr::from_bytes_with_nul_unchecked(b".so\0") }; +#[allow(unsafe_code)] +pub const CONFIG_IASL: &::core::ffi::CStr =3D + unsafe { ::core::ffi::CStr::from_bytes_with_nul_unchecked(b"/bin/iasl\= 0") }; +#[allow(unsafe_code)] +pub const CONFIG_PREFIX: &::core::ffi::CStr =3D + unsafe { ::core::ffi::CStr::from_bytes_with_nul_unchecked(b"/usr/local= \0") }; +#[allow(unsafe_code)] +pub const CONFIG_QEMU_CONFDIR: &::core::ffi::CStr =3D + unsafe { ::core::ffi::CStr::from_bytes_with_nul_unchecked(b"/usr/local= /etc/qemu\0") }; +#[allow(unsafe_code)] +pub const CONFIG_QEMU_DATADIR: &::core::ffi::CStr =3D + unsafe { ::core::ffi::CStr::from_bytes_with_nul_unchecked(b"/usr/local= /share/qemu\0") }; +#[allow(unsafe_code)] +pub const CONFIG_QEMU_DESKTOPDIR: &::core::ffi::CStr =3D + unsafe { ::core::ffi::CStr::from_bytes_with_nul_unchecked(b"/usr/local= /share/applications\0") }; +#[allow(unsafe_code)] +pub const CONFIG_QEMU_HELPERDIR: &::core::ffi::CStr =3D + unsafe { ::core::ffi::CStr::from_bytes_with_nul_unchecked(b"/usr/local= /libexec\0") }; +#[allow(unsafe_code)] +pub const CONFIG_QEMU_ICONDIR: &::core::ffi::CStr =3D + unsafe { ::core::ffi::CStr::from_bytes_with_nul_unchecked(b"/usr/local= /share/icons\0") }; +#[allow(unsafe_code)] +pub const CONFIG_QEMU_LOCALEDIR: &::core::ffi::CStr =3D + unsafe { ::core::ffi::CStr::from_bytes_with_nul_unchecked(b"/usr/local= /share/locale\0") }; +#[allow(unsafe_code)] +pub const CONFIG_QEMU_LOCALSTATEDIR: &::core::ffi::CStr =3D + unsafe { ::core::ffi::CStr::from_bytes_with_nul_unchecked(b"/var/local= \0") }; +#[allow(unsafe_code)] +pub const CONFIG_QEMU_MODDIR: &::core::ffi::CStr =3D unsafe { + ::core::ffi::CStr::from_bytes_with_nul_unchecked(b"/usr/local/lib/x86_= 64-linux-gnu/qemu\0") +}; +#[allow(unsafe_code)] +pub const CONFIG_SMBD_COMMAND: &::core::ffi::CStr =3D + unsafe { ::core::ffi::CStr::from_bytes_with_nul_unchecked(b"/usr/sbin/= smbd\0") }; +#[allow(unsafe_code)] +pub const CONFIG_SYSCONFDIR: &::core::ffi::CStr =3D + unsafe { ::core::ffi::CStr::from_bytes_with_nul_unchecked(b"/usr/local= /etc\0") }; +pub const CONFIG_TCG: u32 =3D 1; +#[allow(unsafe_code)] +pub const CONFIG_TLS_PRIORITY: &::core::ffi::CStr =3D + unsafe { ::core::ffi::CStr::from_bytes_with_nul_unchecked(b"NORMAL\0")= }; +#[allow(unsafe_code)] +pub const CONFIG_TRACE_FILE: &::core::ffi::CStr =3D + unsafe { ::core::ffi::CStr::from_bytes_with_nul_unchecked(b"trace\0") = }; +pub const CONFIG_XEN_CTRL_INTERFACE_VERSION: u32 =3D 41700; +pub const HOST_X86_64: u32 =3D 1; +#[allow(unsafe_code)] +pub const QEMU_VERSION: &::core::ffi::CStr =3D + unsafe { ::core::ffi::CStr::from_bytes_with_nul_unchecked(b"9.0.50\0")= }; +pub const QEMU_VERSION_MAJOR: u32 =3D 9; +pub const QEMU_VERSION_MICRO: u32 =3D 50; +pub const QEMU_VERSION_MINOR: u32 =3D 0; +pub const CONFIG_I386_DIS: u32 =3D 1; +pub const CONFIG_SOFTMMU: u32 =3D 1; +pub const CONFIG_SYSTEM_ONLY: u32 =3D 1; +pub const CONFIG_TCG_BUILTIN: u32 =3D 1; +pub const TARGET_AARCH64: u32 =3D 1; +pub const TARGET_ARM: u32 =3D 1; +pub const TARGET_BIG_ENDIAN: u32 =3D 0; +pub const TARGET_KVM_HAVE_GUEST_DEBUG: u32 =3D 1; +#[allow(unsafe_code)] +pub const TARGET_NAME: &::core::ffi::CStr =3D + unsafe { ::core::ffi::CStr::from_bytes_with_nul_unchecked(b"aarch64\0"= ) }; +pub const TARGET_NEED_FDT: u32 =3D 1; +pub const TARGET_SUPPORTS_MTTCG: u32 =3D 1; +pub const __GNUC_VA_LIST: u32 =3D 1; +pub const _FEATURES_H: u32 =3D 1; +pub const _ISOC95_SOURCE: u32 =3D 1; +pub const _ISOC99_SOURCE: u32 =3D 1; +pub const _ISOC11_SOURCE: u32 =3D 1; +pub const _ISOC2X_SOURCE: u32 =3D 1; +pub const _POSIX_SOURCE: u32 =3D 1; +pub const _POSIX_C_SOURCE: u32 =3D 200809; +pub const _XOPEN_SOURCE: u32 =3D 700; +pub const _XOPEN_SOURCE_EXTENDED: u32 =3D 1; +pub const _LARGEFILE64_SOURCE: u32 =3D 1; +pub const _DEFAULT_SOURCE: u32 =3D 1; +pub const _ATFILE_SOURCE: u32 =3D 1; +pub const _DYNAMIC_STACK_SIZE_SOURCE: u32 =3D 1; +pub const __GLIBC_USE_ISOC2X: u32 =3D 1; +pub const __USE_ISOC11: u32 =3D 1; +pub const __USE_ISOC99: u32 =3D 1; +pub const __USE_ISOC95: u32 =3D 1; +pub const __USE_POSIX: u32 =3D 1; +pub const __USE_POSIX2: u32 =3D 1; +pub const __USE_POSIX199309: u32 =3D 1; +pub const __USE_POSIX199506: u32 =3D 1; +pub const __USE_XOPEN2K: u32 =3D 1; +pub const __USE_XOPEN2K8: u32 =3D 1; +pub const __USE_XOPEN: u32 =3D 1; +pub const __USE_XOPEN_EXTENDED: u32 =3D 1; +pub const __USE_UNIX98: u32 =3D 1; +pub const _LARGEFILE_SOURCE: u32 =3D 1; +pub const __USE_XOPEN2K8XSI: u32 =3D 1; +pub const __USE_XOPEN2KXSI: u32 =3D 1; +pub const __USE_LARGEFILE: u32 =3D 1; +pub const __USE_LARGEFILE64: u32 =3D 1; +pub const __USE_FILE_OFFSET64: u32 =3D 1; +pub const __WORDSIZE: u32 =3D 64; +pub const __WORDSIZE_TIME64_COMPAT32: u32 =3D 1; +pub const __SYSCALL_WORDSIZE: u32 =3D 64; +pub const __TIMESIZE: u32 =3D 64; +pub const __USE_MISC: u32 =3D 1; +pub const __USE_ATFILE: u32 =3D 1; +pub const __USE_DYNAMIC_STACK_SIZE: u32 =3D 1; +pub const __USE_GNU: u32 =3D 1; +pub const __USE_FORTIFY_LEVEL: u32 =3D 0; +pub const __GLIBC_USE_DEPRECATED_GETS: u32 =3D 0; +pub const __GLIBC_USE_DEPRECATED_SCANF: u32 =3D 0; +pub const _STDC_PREDEF_H: u32 =3D 1; +pub const __STDC_IEC_559__: u32 =3D 1; +pub const __STDC_IEC_60559_BFP__: u32 =3D 201404; +pub const __STDC_IEC_559_COMPLEX__: u32 =3D 1; +pub const __STDC_IEC_60559_COMPLEX__: u32 =3D 201404; +pub const __STDC_ISO_10646__: u32 =3D 201706; +pub const __GNU_LIBRARY__: u32 =3D 6; +pub const __GLIBC__: u32 =3D 2; +pub const __GLIBC_MINOR__: u32 =3D 36; +pub const _SYS_CDEFS_H: u32 =3D 1; +pub const __glibc_c99_flexarr_available: u32 =3D 1; +pub const __LDOUBLE_REDIRECTS_TO_FLOAT128_ABI: u32 =3D 0; +pub const __HAVE_GENERIC_SELECTION: u32 =3D 1; +pub const __GLIBC_USE_LIB_EXT2: u32 =3D 1; +pub const __GLIBC_USE_IEC_60559_BFP_EXT: u32 =3D 1; +pub const __GLIBC_USE_IEC_60559_BFP_EXT_C2X: u32 =3D 1; +pub const __GLIBC_USE_IEC_60559_EXT: u32 =3D 1; +pub const __GLIBC_USE_IEC_60559_FUNCS_EXT: u32 =3D 1; +pub const __GLIBC_USE_IEC_60559_FUNCS_EXT_C2X: u32 =3D 1; +pub const __GLIBC_USE_IEC_60559_TYPES_EXT: u32 =3D 1; +pub const _BITS_TYPES_H: u32 =3D 1; +pub const _BITS_TYPESIZES_H: u32 =3D 1; +pub const __OFF_T_MATCHES_OFF64_T: u32 =3D 1; +pub const __INO_T_MATCHES_INO64_T: u32 =3D 1; +pub const __RLIM_T_MATCHES_RLIM64_T: u32 =3D 1; +pub const __STATFS_MATCHES_STATFS64: u32 =3D 1; +pub const __KERNEL_OLD_TIMEVAL_MATCHES_TIMEVAL64: u32 =3D 1; +pub const __FD_SETSIZE: u32 =3D 1024; +pub const _BITS_TIME64_H: u32 =3D 1; +pub const _BITS_WCHAR_H: u32 =3D 1; +pub const _BITS_STDINT_INTN_H: u32 =3D 1; +pub const _BITS_STDINT_UINTN_H: u32 =3D 1; +pub const _SYS_TYPES_H: u32 =3D 1; +pub const __clock_t_defined: u32 =3D 1; +pub const __clockid_t_defined: u32 =3D 1; +pub const __time_t_defined: u32 =3D 1; +pub const __timer_t_defined: u32 =3D 1; +pub const __BIT_TYPES_DEFINED__: u32 =3D 1; +pub const _ENDIAN_H: u32 =3D 1; +pub const _BITS_ENDIAN_H: u32 =3D 1; +pub const __LITTLE_ENDIAN: u32 =3D 1234; +pub const __BIG_ENDIAN: u32 =3D 4321; +pub const __PDP_ENDIAN: u32 =3D 3412; +pub const _BITS_ENDIANNESS_H: u32 =3D 1; +pub const __BYTE_ORDER: u32 =3D 1234; +pub const __FLOAT_WORD_ORDER: u32 =3D 1234; +pub const LITTLE_ENDIAN: u32 =3D 1234; +pub const BIG_ENDIAN: u32 =3D 4321; +pub const PDP_ENDIAN: u32 =3D 3412; +pub const BYTE_ORDER: u32 =3D 1234; +pub const _BITS_BYTESWAP_H: u32 =3D 1; +pub const _BITS_UINTN_IDENTITY_H: u32 =3D 1; +pub const _SYS_SELECT_H: u32 =3D 1; +pub const __sigset_t_defined: u32 =3D 1; +pub const __timeval_defined: u32 =3D 1; +pub const _STRUCT_TIMESPEC: u32 =3D 1; +pub const FD_SETSIZE: u32 =3D 1024; +pub const _BITS_PTHREADTYPES_COMMON_H: u32 =3D 1; +pub const _THREAD_SHARED_TYPES_H: u32 =3D 1; +pub const _BITS_PTHREADTYPES_ARCH_H: u32 =3D 1; +pub const __SIZEOF_PTHREAD_MUTEX_T: u32 =3D 40; +pub const __SIZEOF_PTHREAD_ATTR_T: u32 =3D 56; +pub const __SIZEOF_PTHREAD_RWLOCK_T: u32 =3D 56; +pub const __SIZEOF_PTHREAD_BARRIER_T: u32 =3D 32; +pub const __SIZEOF_PTHREAD_MUTEXATTR_T: u32 =3D 4; +pub const __SIZEOF_PTHREAD_COND_T: u32 =3D 48; +pub const __SIZEOF_PTHREAD_CONDATTR_T: u32 =3D 4; +pub const __SIZEOF_PTHREAD_RWLOCKATTR_T: u32 =3D 8; +pub const __SIZEOF_PTHREAD_BARRIERATTR_T: u32 =3D 4; +pub const _THREAD_MUTEX_INTERNAL_H: u32 =3D 1; +pub const __PTHREAD_MUTEX_HAVE_PREV: u32 =3D 1; +pub const __have_pthread_attr_t: u32 =3D 1; +pub const _STDLIB_H: u32 =3D 1; +pub const WNOHANG: u32 =3D 1; +pub const WUNTRACED: u32 =3D 2; +pub const WSTOPPED: u32 =3D 2; +pub const WEXITED: u32 =3D 4; +pub const WCONTINUED: u32 =3D 8; +pub const WNOWAIT: u32 =3D 16777216; +pub const __WNOTHREAD: u32 =3D 536870912; +pub const __WALL: u32 =3D 1073741824; +pub const __WCLONE: u32 =3D 2147483648; +pub const __W_CONTINUED: u32 =3D 65535; +pub const __WCOREFLAG: u32 =3D 128; +pub const __HAVE_FLOAT128: u32 =3D 0; +pub const __HAVE_DISTINCT_FLOAT128: u32 =3D 0; +pub const __HAVE_FLOAT64X: u32 =3D 1; +pub const __HAVE_FLOAT64X_LONG_DOUBLE: u32 =3D 1; +pub const __HAVE_FLOAT16: u32 =3D 0; +pub const __HAVE_FLOAT32: u32 =3D 1; +pub const __HAVE_FLOAT64: u32 =3D 1; +pub const __HAVE_FLOAT32X: u32 =3D 1; +pub const __HAVE_FLOAT128X: u32 =3D 0; +pub const __HAVE_DISTINCT_FLOAT16: u32 =3D 0; +pub const __HAVE_DISTINCT_FLOAT32: u32 =3D 0; +pub const __HAVE_DISTINCT_FLOAT64: u32 =3D 0; +pub const __HAVE_DISTINCT_FLOAT32X: u32 =3D 0; +pub const __HAVE_DISTINCT_FLOAT64X: u32 =3D 0; +pub const __HAVE_DISTINCT_FLOAT128X: u32 =3D 0; +pub const __HAVE_FLOATN_NOT_TYPEDEF: u32 =3D 0; +pub const __ldiv_t_defined: u32 =3D 1; +pub const __lldiv_t_defined: u32 =3D 1; +pub const RAND_MAX: u32 =3D 2147483647; +pub const EXIT_FAILURE: u32 =3D 1; +pub const EXIT_SUCCESS: u32 =3D 0; +pub const _BITS_TYPES_LOCALE_T_H: u32 =3D 1; +pub const _BITS_TYPES___LOCALE_T_H: u32 =3D 1; +pub const _ALLOCA_H: u32 =3D 1; +pub const _____fpos_t_defined: u32 =3D 1; +pub const ____mbstate_t_defined: u32 =3D 1; +pub const _____fpos64_t_defined: u32 =3D 1; +pub const ____FILE_defined: u32 =3D 1; +pub const __FILE_defined: u32 =3D 1; +pub const __struct_FILE_defined: u32 =3D 1; +pub const _IO_EOF_SEEN: u32 =3D 16; +pub const _IO_ERR_SEEN: u32 =3D 32; +pub const _IO_USER_LOCK: u32 =3D 32768; +pub const __cookie_io_functions_t_defined: u32 =3D 1; +pub const _BITS_STDIO_LIM_H: u32 =3D 1; +pub const L_tmpnam: u32 =3D 20; +pub const TMP_MAX: u32 =3D 238328; +pub const FILENAME_MAX: u32 =3D 4096; +pub const L_ctermid: u32 =3D 9; +pub const L_cuserid: u32 =3D 9; +pub const FOPEN_MAX: u32 =3D 16; +pub const _STRING_H: u32 =3D 1; +pub const _STRINGS_H: u32 =3D 1; +pub const _BITS_POSIX1_LIM_H: u32 =3D 1; +pub const _POSIX_AIO_LISTIO_MAX: u32 =3D 2; +pub const _POSIX_AIO_MAX: u32 =3D 1; +pub const _POSIX_ARG_MAX: u32 =3D 4096; +pub const _POSIX_CHILD_MAX: u32 =3D 25; +pub const _POSIX_DELAYTIMER_MAX: u32 =3D 32; +pub const _POSIX_HOST_NAME_MAX: u32 =3D 255; +pub const _POSIX_LINK_MAX: u32 =3D 8; +pub const _POSIX_LOGIN_NAME_MAX: u32 =3D 9; +pub const _POSIX_MAX_CANON: u32 =3D 255; +pub const _POSIX_MAX_INPUT: u32 =3D 255; +pub const _POSIX_MQ_OPEN_MAX: u32 =3D 8; +pub const _POSIX_MQ_PRIO_MAX: u32 =3D 32; +pub const _POSIX_NAME_MAX: u32 =3D 14; +pub const _POSIX_NGROUPS_MAX: u32 =3D 8; +pub const _POSIX_OPEN_MAX: u32 =3D 20; +pub const _POSIX_FD_SETSIZE: u32 =3D 20; +pub const _POSIX_PATH_MAX: u32 =3D 256; +pub const _POSIX_PIPE_BUF: u32 =3D 512; +pub const _POSIX_RE_DUP_MAX: u32 =3D 255; +pub const _POSIX_RTSIG_MAX: u32 =3D 8; +pub const _POSIX_SEM_NSEMS_MAX: u32 =3D 256; +pub const _POSIX_SEM_VALUE_MAX: u32 =3D 32767; +pub const _POSIX_SIGQUEUE_MAX: u32 =3D 32; +pub const _POSIX_SSIZE_MAX: u32 =3D 32767; +pub const _POSIX_STREAM_MAX: u32 =3D 8; +pub const _POSIX_SYMLINK_MAX: u32 =3D 255; +pub const _POSIX_SYMLOOP_MAX: u32 =3D 8; +pub const _POSIX_TIMER_MAX: u32 =3D 32; +pub const _POSIX_TTY_NAME_MAX: u32 =3D 9; +pub const _POSIX_TZNAME_MAX: u32 =3D 6; +pub const _POSIX_QLIMIT: u32 =3D 1; +pub const _POSIX_HIWAT: u32 =3D 512; +pub const _POSIX_UIO_MAXIOV: u32 =3D 16; +pub const _POSIX_CLOCKRES_MIN: u32 =3D 20000000; +pub const _POSIX_THREAD_KEYS_MAX: u32 =3D 128; +pub const PTHREAD_KEYS_MAX: u32 =3D 1024; +pub const _POSIX_THREAD_DESTRUCTOR_ITERATIONS: u32 =3D 4; +pub const PTHREAD_DESTRUCTOR_ITERATIONS: u32 =3D 4; +pub const _POSIX_THREAD_THREADS_MAX: u32 =3D 64; +pub const AIO_PRIO_DELTA_MAX: u32 =3D 20; +pub const __SC_THREAD_STACK_MIN_VALUE: u32 =3D 75; +pub const DELAYTIMER_MAX: u32 =3D 2147483647; +pub const TTY_NAME_MAX: u32 =3D 32; +pub const LOGIN_NAME_MAX: u32 =3D 256; +pub const HOST_NAME_MAX: u32 =3D 64; +pub const MQ_PRIO_MAX: u32 =3D 32768; +pub const SEM_VALUE_MAX: u32 =3D 2147483647; +pub const _BITS_POSIX2_LIM_H: u32 =3D 1; +pub const _POSIX2_BC_BASE_MAX: u32 =3D 99; +pub const _POSIX2_BC_DIM_MAX: u32 =3D 2048; +pub const _POSIX2_BC_SCALE_MAX: u32 =3D 99; +pub const _POSIX2_BC_STRING_MAX: u32 =3D 1000; +pub const _POSIX2_COLL_WEIGHTS_MAX: u32 =3D 2; +pub const _POSIX2_EXPR_NEST_MAX: u32 =3D 32; +pub const _POSIX2_LINE_MAX: u32 =3D 2048; +pub const _POSIX2_RE_DUP_MAX: u32 =3D 255; +pub const _POSIX2_CHARCLASS_NAME_MAX: u32 =3D 14; +pub const BC_BASE_MAX: u32 =3D 99; +pub const BC_DIM_MAX: u32 =3D 2048; +pub const BC_SCALE_MAX: u32 =3D 99; +pub const BC_STRING_MAX: u32 =3D 1000; +pub const COLL_WEIGHTS_MAX: u32 =3D 255; +pub const EXPR_NEST_MAX: u32 =3D 32; +pub const LINE_MAX: u32 =3D 2048; +pub const CHARCLASS_NAME_MAX: u32 =3D 2048; +pub const RE_DUP_MAX: u32 =3D 32767; +pub const _XOPEN_LIM_H: u32 =3D 1; +pub const _XOPEN_IOV_MAX: u32 =3D 16; +pub const _BITS_UIO_LIM_H: u32 =3D 1; +pub const __IOV_MAX: u32 =3D 1024; +pub const IOV_MAX: u32 =3D 1024; +pub const NL_ARGMAX: u32 =3D 4096; +pub const NL_LANGMAX: u32 =3D 2048; +pub const NZERO: u32 =3D 20; +pub const WORD_BIT: u32 =3D 32; +pub const LONG_BIT: u32 =3D 64; +pub const _UNISTD_H: u32 =3D 1; +pub const _POSIX_VERSION: u32 =3D 200809; +pub const __POSIX2_THIS_VERSION: u32 =3D 200809; +pub const _POSIX2_VERSION: u32 =3D 200809; +pub const _POSIX2_C_VERSION: u32 =3D 200809; +pub const _POSIX2_C_BIND: u32 =3D 200809; +pub const _POSIX2_C_DEV: u32 =3D 200809; +pub const _POSIX2_SW_DEV: u32 =3D 200809; +pub const _POSIX2_LOCALEDEF: u32 =3D 200809; +pub const _XOPEN_VERSION: u32 =3D 700; +pub const _XOPEN_XCU_VERSION: u32 =3D 4; +pub const _XOPEN_XPG2: u32 =3D 1; +pub const _XOPEN_XPG3: u32 =3D 1; +pub const _XOPEN_XPG4: u32 =3D 1; +pub const _XOPEN_UNIX: u32 =3D 1; +pub const _XOPEN_ENH_I18N: u32 =3D 1; +pub const _XOPEN_LEGACY: u32 =3D 1; +pub const _BITS_POSIX_OPT_H: u32 =3D 1; +pub const _POSIX_JOB_CONTROL: u32 =3D 1; +pub const _POSIX_SAVED_IDS: u32 =3D 1; +pub const _POSIX_PRIORITY_SCHEDULING: u32 =3D 200809; +pub const _POSIX_SYNCHRONIZED_IO: u32 =3D 200809; +pub const _POSIX_FSYNC: u32 =3D 200809; +pub const _POSIX_MAPPED_FILES: u32 =3D 200809; +pub const _POSIX_MEMLOCK: u32 =3D 200809; +pub const _POSIX_MEMLOCK_RANGE: u32 =3D 200809; +pub const _POSIX_MEMORY_PROTECTION: u32 =3D 200809; +pub const _POSIX_CHOWN_RESTRICTED: u32 =3D 0; +pub const _POSIX_VDISABLE: u8 =3D 0u8; +pub const _POSIX_NO_TRUNC: u32 =3D 1; +pub const _XOPEN_REALTIME: u32 =3D 1; +pub const _XOPEN_REALTIME_THREADS: u32 =3D 1; +pub const _XOPEN_SHM: u32 =3D 1; +pub const _POSIX_THREADS: u32 =3D 200809; +pub const _POSIX_REENTRANT_FUNCTIONS: u32 =3D 1; +pub const _POSIX_THREAD_SAFE_FUNCTIONS: u32 =3D 200809; +pub const _POSIX_THREAD_PRIORITY_SCHEDULING: u32 =3D 200809; +pub const _POSIX_THREAD_ATTR_STACKSIZE: u32 =3D 200809; +pub const _POSIX_THREAD_ATTR_STACKADDR: u32 =3D 200809; +pub const _POSIX_THREAD_PRIO_INHERIT: u32 =3D 200809; +pub const _POSIX_THREAD_PRIO_PROTECT: u32 =3D 200809; +pub const _POSIX_THREAD_ROBUST_PRIO_INHERIT: u32 =3D 200809; +pub const _POSIX_THREAD_ROBUST_PRIO_PROTECT: i32 =3D -1; +pub const _POSIX_SEMAPHORES: u32 =3D 200809; +pub const _POSIX_REALTIME_SIGNALS: u32 =3D 200809; +pub const _POSIX_ASYNCHRONOUS_IO: u32 =3D 200809; +pub const _POSIX_ASYNC_IO: u32 =3D 1; +pub const _LFS_ASYNCHRONOUS_IO: u32 =3D 1; +pub const _POSIX_PRIORITIZED_IO: u32 =3D 200809; +pub const _LFS64_ASYNCHRONOUS_IO: u32 =3D 1; +pub const _LFS_LARGEFILE: u32 =3D 1; +pub const _LFS64_LARGEFILE: u32 =3D 1; +pub const _LFS64_STDIO: u32 =3D 1; +pub const _POSIX_SHARED_MEMORY_OBJECTS: u32 =3D 200809; +pub const _POSIX_CPUTIME: u32 =3D 0; +pub const _POSIX_THREAD_CPUTIME: u32 =3D 0; +pub const _POSIX_REGEXP: u32 =3D 1; +pub const _POSIX_READER_WRITER_LOCKS: u32 =3D 200809; +pub const _POSIX_SHELL: u32 =3D 1; +pub const _POSIX_TIMEOUTS: u32 =3D 200809; +pub const _POSIX_SPIN_LOCKS: u32 =3D 200809; +pub const _POSIX_SPAWN: u32 =3D 200809; +pub const _POSIX_TIMERS: u32 =3D 200809; +pub const _POSIX_BARRIERS: u32 =3D 200809; +pub const _POSIX_MESSAGE_PASSING: u32 =3D 200809; +pub const _POSIX_THREAD_PROCESS_SHARED: u32 =3D 200809; +pub const _POSIX_MONOTONIC_CLOCK: u32 =3D 0; +pub const _POSIX_CLOCK_SELECTION: u32 =3D 200809; +pub const _POSIX_ADVISORY_INFO: u32 =3D 200809; +pub const _POSIX_IPV6: u32 =3D 200809; +pub const _POSIX_RAW_SOCKETS: u32 =3D 200809; +pub const _POSIX2_CHAR_TERM: u32 =3D 200809; +pub const _POSIX_SPORADIC_SERVER: i32 =3D -1; +pub const _POSIX_THREAD_SPORADIC_SERVER: i32 =3D -1; +pub const _POSIX_TRACE: i32 =3D -1; +pub const _POSIX_TRACE_EVENT_FILTER: i32 =3D -1; +pub const _POSIX_TRACE_INHERIT: i32 =3D -1; +pub const _POSIX_TRACE_LOG: i32 =3D -1; +pub const _POSIX_TYPED_MEMORY_OBJECTS: i32 =3D -1; +pub const _POSIX_V7_LPBIG_OFFBIG: i32 =3D -1; +pub const _POSIX_V6_LPBIG_OFFBIG: i32 =3D -1; +pub const _XBS5_LPBIG_OFFBIG: i32 =3D -1; +pub const _POSIX_V7_LP64_OFF64: u32 =3D 1; +pub const _POSIX_V6_LP64_OFF64: u32 =3D 1; +pub const _XBS5_LP64_OFF64: u32 =3D 1; +#[allow(unsafe_code)] +pub const __ILP32_OFF32_CFLAGS: &::core::ffi::CStr =3D + unsafe { ::core::ffi::CStr::from_bytes_with_nul_unchecked(b"-m32\0") }; +#[allow(unsafe_code)] +pub const __ILP32_OFF32_LDFLAGS: &::core::ffi::CStr =3D + unsafe { ::core::ffi::CStr::from_bytes_with_nul_unchecked(b"-m32\0") }; +#[allow(unsafe_code)] +pub const __ILP32_OFFBIG_CFLAGS: &::core::ffi::CStr =3D unsafe { + ::core::ffi::CStr::from_bytes_with_nul_unchecked( + b"-m32 -D_LARGEFILE_SOURCE -D_FILE_OFFSET_BITS=3D64\0", + ) +}; +#[allow(unsafe_code)] +pub const __ILP32_OFFBIG_LDFLAGS: &::core::ffi::CStr =3D + unsafe { ::core::ffi::CStr::from_bytes_with_nul_unchecked(b"-m32\0") }; +#[allow(unsafe_code)] +pub const __LP64_OFF64_CFLAGS: &::core::ffi::CStr =3D + unsafe { ::core::ffi::CStr::from_bytes_with_nul_unchecked(b"-m64\0") }; +#[allow(unsafe_code)] +pub const __LP64_OFF64_LDFLAGS: &::core::ffi::CStr =3D + unsafe { ::core::ffi::CStr::from_bytes_with_nul_unchecked(b"-m64\0") }; +pub const STDIN_FILENO: u32 =3D 0; +pub const STDOUT_FILENO: u32 =3D 1; +pub const STDERR_FILENO: u32 =3D 2; +pub const R_OK: u32 =3D 4; +pub const W_OK: u32 =3D 2; +pub const X_OK: u32 =3D 1; +pub const F_OK: u32 =3D 0; +pub const L_SET: u32 =3D 0; +pub const L_INCR: u32 =3D 1; +pub const L_XTND: u32 =3D 2; +pub const _GETOPT_POSIX_H: u32 =3D 1; +pub const _GETOPT_CORE_H: u32 =3D 1; +pub const F_ULOCK: u32 =3D 0; +pub const F_LOCK: u32 =3D 1; +pub const F_TLOCK: u32 =3D 2; +pub const F_TEST: u32 =3D 3; +pub const CLOSE_RANGE_UNSHARE: u32 =3D 2; +pub const CLOSE_RANGE_CLOEXEC: u32 =3D 4; +pub const _TIME_H: u32 =3D 1; +pub const _BITS_TIME_H: u32 =3D 1; +pub const CLOCK_REALTIME: u32 =3D 0; +pub const CLOCK_MONOTONIC: u32 =3D 1; +pub const CLOCK_PROCESS_CPUTIME_ID: u32 =3D 2; +pub const CLOCK_THREAD_CPUTIME_ID: u32 =3D 3; +pub const CLOCK_MONOTONIC_RAW: u32 =3D 4; +pub const CLOCK_REALTIME_COARSE: u32 =3D 5; +pub const CLOCK_MONOTONIC_COARSE: u32 =3D 6; +pub const CLOCK_BOOTTIME: u32 =3D 7; +pub const CLOCK_REALTIME_ALARM: u32 =3D 8; +pub const CLOCK_BOOTTIME_ALARM: u32 =3D 9; +pub const CLOCK_TAI: u32 =3D 11; +pub const TIMER_ABSTIME: u32 =3D 1; +pub const _BITS_TIMEX_H: u32 =3D 1; +pub const ADJ_OFFSET: u32 =3D 1; +pub const ADJ_FREQUENCY: u32 =3D 2; +pub const ADJ_MAXERROR: u32 =3D 4; +pub const ADJ_ESTERROR: u32 =3D 8; +pub const ADJ_STATUS: u32 =3D 16; +pub const ADJ_TIMECONST: u32 =3D 32; +pub const ADJ_TAI: u32 =3D 128; +pub const ADJ_SETOFFSET: u32 =3D 256; +pub const ADJ_MICRO: u32 =3D 4096; +pub const ADJ_NANO: u32 =3D 8192; +pub const ADJ_TICK: u32 =3D 16384; +pub const ADJ_OFFSET_SINGLESHOT: u32 =3D 32769; +pub const ADJ_OFFSET_SS_READ: u32 =3D 40961; +pub const MOD_OFFSET: u32 =3D 1; +pub const MOD_FREQUENCY: u32 =3D 2; +pub const MOD_MAXERROR: u32 =3D 4; +pub const MOD_ESTERROR: u32 =3D 8; +pub const MOD_STATUS: u32 =3D 16; +pub const MOD_TIMECONST: u32 =3D 32; +pub const MOD_CLKB: u32 =3D 16384; +pub const MOD_CLKA: u32 =3D 32769; +pub const MOD_TAI: u32 =3D 128; +pub const MOD_MICRO: u32 =3D 4096; +pub const MOD_NANO: u32 =3D 8192; +pub const STA_PLL: u32 =3D 1; +pub const STA_PPSFREQ: u32 =3D 2; +pub const STA_PPSTIME: u32 =3D 4; +pub const STA_FLL: u32 =3D 8; +pub const STA_INS: u32 =3D 16; +pub const STA_DEL: u32 =3D 32; +pub const STA_UNSYNC: u32 =3D 64; +pub const STA_FREQHOLD: u32 =3D 128; +pub const STA_PPSSIGNAL: u32 =3D 256; +pub const STA_PPSJITTER: u32 =3D 512; +pub const STA_PPSWANDER: u32 =3D 1024; +pub const STA_PPSERROR: u32 =3D 2048; +pub const STA_CLOCKERR: u32 =3D 4096; +pub const STA_NANO: u32 =3D 8192; +pub const STA_MODE: u32 =3D 16384; +pub const STA_CLK: u32 =3D 32768; +pub const STA_RONLY: u32 =3D 65280; +pub const __struct_tm_defined: u32 =3D 1; +pub const __itimerspec_defined: u32 =3D 1; +pub const TIME_UTC: u32 =3D 1; +pub const EPERM: u32 =3D 1; +pub const ENOENT: u32 =3D 2; +pub const ESRCH: u32 =3D 3; +pub const EINTR: u32 =3D 4; +pub const EIO: u32 =3D 5; +pub const ENXIO: u32 =3D 6; +pub const E2BIG: u32 =3D 7; +pub const ENOEXEC: u32 =3D 8; +pub const EBADF: u32 =3D 9; +pub const ECHILD: u32 =3D 10; +pub const EAGAIN: u32 =3D 11; +pub const ENOMEM: u32 =3D 12; +pub const EACCES: u32 =3D 13; +pub const EFAULT: u32 =3D 14; +pub const ENOTBLK: u32 =3D 15; +pub const EBUSY: u32 =3D 16; +pub const EEXIST: u32 =3D 17; +pub const EXDEV: u32 =3D 18; +pub const ENODEV: u32 =3D 19; +pub const ENOTDIR: u32 =3D 20; +pub const EISDIR: u32 =3D 21; +pub const EINVAL: u32 =3D 22; +pub const ENFILE: u32 =3D 23; +pub const EMFILE: u32 =3D 24; +pub const ENOTTY: u32 =3D 25; +pub const ETXTBSY: u32 =3D 26; +pub const EFBIG: u32 =3D 27; +pub const ENOSPC: u32 =3D 28; +pub const ESPIPE: u32 =3D 29; +pub const EROFS: u32 =3D 30; +pub const EMLINK: u32 =3D 31; +pub const EPIPE: u32 =3D 32; +pub const EDOM: u32 =3D 33; +pub const ERANGE: u32 =3D 34; +pub const __error_t_defined: u32 =3D 1; +pub const __iovec_defined: u32 =3D 1; +pub const O_ACCMODE: u32 =3D 3; +pub const O_RDONLY: u32 =3D 0; +pub const O_WRONLY: u32 =3D 1; +pub const O_RDWR: u32 =3D 2; +pub const O_CREAT: u32 =3D 64; +pub const O_EXCL: u32 =3D 128; +pub const O_NOCTTY: u32 =3D 256; +pub const O_TRUNC: u32 =3D 512; +pub const O_APPEND: u32 =3D 1024; +pub const O_NONBLOCK: u32 =3D 2048; +pub const O_NDELAY: u32 =3D 2048; +pub const O_SYNC: u32 =3D 1052672; +pub const O_FSYNC: u32 =3D 1052672; +pub const O_ASYNC: u32 =3D 8192; +pub const __O_DIRECTORY: u32 =3D 65536; +pub const __O_NOFOLLOW: u32 =3D 131072; +pub const __O_CLOEXEC: u32 =3D 524288; +pub const __O_DIRECT: u32 =3D 16384; +pub const __O_NOATIME: u32 =3D 262144; +pub const __O_PATH: u32 =3D 2097152; +pub const __O_DSYNC: u32 =3D 4096; +pub const __O_TMPFILE: u32 =3D 4259840; +pub const F_GETLK: u32 =3D 5; +pub const F_SETLK: u32 =3D 6; +pub const F_SETLKW: u32 =3D 7; +pub const F_OFD_GETLK: u32 =3D 36; +pub const F_OFD_SETLK: u32 =3D 37; +pub const F_OFD_SETLKW: u32 =3D 38; +pub const O_LARGEFILE: u32 =3D 0; +pub const O_DIRECTORY: u32 =3D 65536; +pub const O_NOFOLLOW: u32 =3D 131072; +pub const O_CLOEXEC: u32 =3D 524288; +pub const O_DIRECT: u32 =3D 16384; +pub const O_NOATIME: u32 =3D 262144; +pub const O_PATH: u32 =3D 2097152; +pub const O_TMPFILE: u32 =3D 4259840; +pub const O_DSYNC: u32 =3D 4096; +pub const O_RSYNC: u32 =3D 1052672; +pub const F_DUPFD: u32 =3D 0; +pub const F_GETFD: u32 =3D 1; +pub const F_SETFD: u32 =3D 2; +pub const F_GETFL: u32 =3D 3; +pub const F_SETFL: u32 =3D 4; +pub const __F_SETOWN: u32 =3D 8; +pub const __F_GETOWN: u32 =3D 9; +pub const F_SETOWN: u32 =3D 8; +pub const F_GETOWN: u32 =3D 9; +pub const __F_SETSIG: u32 =3D 10; +pub const __F_GETSIG: u32 =3D 11; +pub const __F_SETOWN_EX: u32 =3D 15; +pub const __F_GETOWN_EX: u32 =3D 16; +pub const F_SETSIG: u32 =3D 10; +pub const F_GETSIG: u32 =3D 11; +pub const F_SETOWN_EX: u32 =3D 15; +pub const F_GETOWN_EX: u32 =3D 16; +pub const F_SETLEASE: u32 =3D 1024; +pub const F_GETLEASE: u32 =3D 1025; +pub const F_NOTIFY: u32 =3D 1026; +pub const F_SETPIPE_SZ: u32 =3D 1031; +pub const F_GETPIPE_SZ: u32 =3D 1032; +pub const F_ADD_SEALS: u32 =3D 1033; +pub const F_GET_SEALS: u32 =3D 1034; +pub const F_GET_RW_HINT: u32 =3D 1035; +pub const F_SET_RW_HINT: u32 =3D 1036; +pub const F_GET_FILE_RW_HINT: u32 =3D 1037; +pub const F_SET_FILE_RW_HINT: u32 =3D 1038; +pub const F_DUPFD_CLOEXEC: u32 =3D 1030; +pub const FD_CLOEXEC: u32 =3D 1; +pub const F_RDLCK: u32 =3D 0; +pub const F_WRLCK: u32 =3D 1; +pub const F_UNLCK: u32 =3D 2; +pub const F_EXLCK: u32 =3D 4; +pub const F_SHLCK: u32 =3D 8; +pub const LOCK_SH: u32 =3D 1; +pub const LOCK_EX: u32 =3D 2; +pub const LOCK_NB: u32 =3D 4; +pub const LOCK_UN: u32 =3D 8; +pub const LOCK_MAND: u32 =3D 32; +pub const LOCK_READ: u32 =3D 64; +pub const LOCK_WRITE: u32 =3D 128; +pub const LOCK_RW: u32 =3D 192; +pub const DN_ACCESS: u32 =3D 1; +pub const DN_MODIFY: u32 =3D 2; +pub const DN_CREATE: u32 =3D 4; +pub const DN_DELETE: u32 =3D 8; +pub const DN_RENAME: u32 =3D 16; +pub const DN_ATTRIB: u32 =3D 32; +pub const DN_MULTISHOT: u32 =3D 2147483648; +pub const F_SEAL_SEAL: u32 =3D 1; +pub const F_SEAL_SHRINK: u32 =3D 2; +pub const F_SEAL_GROW: u32 =3D 4; +pub const F_SEAL_WRITE: u32 =3D 8; +pub const F_SEAL_FUTURE_WRITE: u32 =3D 16; +pub const RWH_WRITE_LIFE_NOT_SET: u32 =3D 0; +pub const RWF_WRITE_LIFE_NOT_SET: u32 =3D 0; +pub const RWH_WRITE_LIFE_NONE: u32 =3D 1; +pub const RWH_WRITE_LIFE_SHORT: u32 =3D 2; +pub const RWH_WRITE_LIFE_MEDIUM: u32 =3D 3; +pub const RWH_WRITE_LIFE_LONG: u32 =3D 4; +pub const RWH_WRITE_LIFE_EXTREME: u32 =3D 5; +pub const FAPPEND: u32 =3D 1024; +pub const FFSYNC: u32 =3D 1052672; +pub const FASYNC: u32 =3D 8192; +pub const FNONBLOCK: u32 =3D 2048; +pub const FNDELAY: u32 =3D 2048; +pub const __POSIX_FADV_DONTNEED: u32 =3D 4; +pub const __POSIX_FADV_NOREUSE: u32 =3D 5; +pub const POSIX_FADV_NORMAL: u32 =3D 0; +pub const POSIX_FADV_RANDOM: u32 =3D 1; +pub const POSIX_FADV_SEQUENTIAL: u32 =3D 2; +pub const POSIX_FADV_WILLNEED: u32 =3D 3; +pub const POSIX_FADV_DONTNEED: u32 =3D 4; +pub const POSIX_FADV_NOREUSE: u32 =3D 5; +pub const SYNC_FILE_RANGE_WAIT_BEFORE: u32 =3D 1; +pub const SYNC_FILE_RANGE_WRITE: u32 =3D 2; +pub const SYNC_FILE_RANGE_WAIT_AFTER: u32 =3D 4; +pub const SYNC_FILE_RANGE_WRITE_AND_WAIT: u32 =3D 7; +pub const SPLICE_F_MOVE: u32 =3D 1; +pub const SPLICE_F_NONBLOCK: u32 =3D 2; +pub const SPLICE_F_MORE: u32 =3D 4; +pub const SPLICE_F_GIFT: u32 =3D 8; +pub const FALLOC_FL_KEEP_SIZE: u32 =3D 1; +pub const FALLOC_FL_PUNCH_HOLE: u32 =3D 2; +pub const FALLOC_FL_NO_HIDE_STALE: u32 =3D 4; +pub const FALLOC_FL_COLLAPSE_RANGE: u32 =3D 8; +pub const FALLOC_FL_ZERO_RANGE: u32 =3D 16; +pub const FALLOC_FL_INSERT_RANGE: u32 =3D 32; +pub const FALLOC_FL_UNSHARE_RANGE: u32 =3D 64; +pub const MAX_HANDLE_SZ: u32 =3D 128; +pub const AT_FDCWD: i32 =3D -100; +pub const AT_SYMLINK_NOFOLLOW: u32 =3D 256; +pub const AT_REMOVEDIR: u32 =3D 512; +pub const AT_SYMLINK_FOLLOW: u32 =3D 1024; +pub const AT_NO_AUTOMOUNT: u32 =3D 2048; +pub const AT_EMPTY_PATH: u32 =3D 4096; +pub const AT_STATX_SYNC_TYPE: u32 =3D 24576; +pub const AT_STATX_SYNC_AS_STAT: u32 =3D 0; +pub const AT_STATX_FORCE_SYNC: u32 =3D 8192; +pub const AT_STATX_DONT_SYNC: u32 =3D 16384; +pub const AT_RECURSIVE: u32 =3D 32768; +pub const AT_EACCESS: u32 =3D 512; +pub const _BITS_STAT_H: u32 =3D 1; +pub const _BITS_STRUCT_STAT_H: u32 =3D 1; +pub const __S_IFMT: u32 =3D 61440; +pub const __S_IFDIR: u32 =3D 16384; +pub const __S_IFCHR: u32 =3D 8192; +pub const __S_IFBLK: u32 =3D 24576; +pub const __S_IFREG: u32 =3D 32768; +pub const __S_IFIFO: u32 =3D 4096; +pub const __S_IFLNK: u32 =3D 40960; +pub const __S_IFSOCK: u32 =3D 49152; +pub const __S_ISUID: u32 =3D 2048; +pub const __S_ISGID: u32 =3D 1024; +pub const __S_ISVTX: u32 =3D 512; +pub const __S_IREAD: u32 =3D 256; +pub const __S_IWRITE: u32 =3D 128; +pub const __S_IEXEC: u32 =3D 64; +pub const UTIME_NOW: u32 =3D 1073741823; +pub const UTIME_OMIT: u32 =3D 1073741822; +pub const _GETOPT_EXT_H: u32 =3D 1; +pub const no_argument: u32 =3D 0; +pub const required_argument: u32 =3D 1; +pub const optional_argument: u32 =3D 2; +pub const _SYS_STAT_H: u32 =3D 1; +pub const S_IREAD: u32 =3D 256; +pub const S_IWRITE: u32 =3D 128; +pub const S_IEXEC: u32 =3D 64; +pub const ACCESSPERMS: u32 =3D 511; +pub const ALLPERMS: u32 =3D 4095; +pub const DEFFILEMODE: u32 =3D 438; +pub const S_BLKSIZE: u32 =3D 512; +pub const __BITS_PER_LONG: u32 =3D 64; +pub const __BITS_PER_LONG_LONG: u32 =3D 64; +pub const STATX_TYPE: u32 =3D 1; +pub const STATX_MODE: u32 =3D 2; +pub const STATX_NLINK: u32 =3D 4; +pub const STATX_UID: u32 =3D 8; +pub const STATX_GID: u32 =3D 16; +pub const STATX_ATIME: u32 =3D 32; +pub const STATX_MTIME: u32 =3D 64; +pub const STATX_CTIME: u32 =3D 128; +pub const STATX_INO: u32 =3D 256; +pub const STATX_SIZE: u32 =3D 512; +pub const STATX_BLOCKS: u32 =3D 1024; +pub const STATX_BASIC_STATS: u32 =3D 2047; +pub const STATX_BTIME: u32 =3D 2048; +pub const STATX_MNT_ID: u32 =3D 4096; +pub const STATX_DIOALIGN: u32 =3D 8192; +pub const STATX__RESERVED: u32 =3D 2147483648; +pub const STATX_ALL: u32 =3D 4095; +pub const STATX_ATTR_COMPRESSED: u32 =3D 4; +pub const STATX_ATTR_IMMUTABLE: u32 =3D 16; +pub const STATX_ATTR_APPEND: u32 =3D 32; +pub const STATX_ATTR_NODUMP: u32 =3D 64; +pub const STATX_ATTR_ENCRYPTED: u32 =3D 2048; +pub const STATX_ATTR_AUTOMOUNT: u32 =3D 4096; +pub const STATX_ATTR_MOUNT_ROOT: u32 =3D 8192; +pub const STATX_ATTR_VERITY: u32 =3D 1048576; +pub const STATX_ATTR_DAX: u32 =3D 2097152; +pub const __statx_timestamp_defined: u32 =3D 1; +pub const __statx_defined: u32 =3D 1; +pub const _SYS_TIME_H: u32 =3D 1; +pub const _SETJMP_H: u32 =3D 1; +pub const _BITS_SETJMP_H: u32 =3D 1; +pub const __jmp_buf_tag_defined: u32 =3D 1; +pub const _BITS_SIGNUM_GENERIC_H: u32 =3D 1; +pub const SIGINT: u32 =3D 2; +pub const SIGILL: u32 =3D 4; +pub const SIGABRT: u32 =3D 6; +pub const SIGFPE: u32 =3D 8; +pub const SIGSEGV: u32 =3D 11; +pub const SIGTERM: u32 =3D 15; +pub const SIGHUP: u32 =3D 1; +pub const SIGQUIT: u32 =3D 3; +pub const SIGTRAP: u32 =3D 5; +pub const SIGKILL: u32 =3D 9; +pub const SIGPIPE: u32 =3D 13; +pub const SIGALRM: u32 =3D 14; +pub const SIGIOT: u32 =3D 6; +pub const _BITS_SIGNUM_ARCH_H: u32 =3D 1; +pub const SIGSTKFLT: u32 =3D 16; +pub const SIGPWR: u32 =3D 30; +pub const SIGBUS: u32 =3D 7; +pub const SIGSYS: u32 =3D 31; +pub const SIGURG: u32 =3D 23; +pub const SIGSTOP: u32 =3D 19; +pub const SIGTSTP: u32 =3D 20; +pub const SIGCONT: u32 =3D 18; +pub const SIGCHLD: u32 =3D 17; +pub const SIGTTIN: u32 =3D 21; +pub const SIGTTOU: u32 =3D 22; +pub const SIGPOLL: u32 =3D 29; +pub const SIGXFSZ: u32 =3D 25; +pub const SIGXCPU: u32 =3D 24; +pub const SIGVTALRM: u32 =3D 26; +pub const SIGPROF: u32 =3D 27; +pub const SIGUSR1: u32 =3D 10; +pub const SIGUSR2: u32 =3D 12; +pub const SIGWINCH: u32 =3D 28; +pub const SIGIO: u32 =3D 29; +pub const SIGCLD: u32 =3D 17; +pub const __SIGRTMIN: u32 =3D 32; +pub const __SIGRTMAX: u32 =3D 64; +pub const _NSIG: u32 =3D 65; +pub const __sig_atomic_t_defined: u32 =3D 1; +pub const __siginfo_t_defined: u32 =3D 1; +pub const __SI_MAX_SIZE: u32 =3D 128; +pub const _BITS_SIGINFO_ARCH_H: u32 =3D 1; +pub const __SI_ERRNO_THEN_CODE: u32 =3D 1; +pub const __SI_HAVE_SIGSYS: u32 =3D 1; +pub const _BITS_SIGINFO_CONSTS_H: u32 =3D 1; +pub const __SI_ASYNCIO_AFTER_SIGIO: u32 =3D 1; +pub const _BITS_SIGINFO_CONSTS_ARCH_H: u32 =3D 1; +pub const __sigevent_t_defined: u32 =3D 1; +pub const __SIGEV_MAX_SIZE: u32 =3D 64; +pub const _BITS_SIGEVENT_CONSTS_H: u32 =3D 1; +pub const NSIG: u32 =3D 65; +pub const _BITS_SIGACTION_H: u32 =3D 1; +pub const SA_NOCLDSTOP: u32 =3D 1; +pub const SA_NOCLDWAIT: u32 =3D 2; +pub const SA_SIGINFO: u32 =3D 4; +pub const SA_ONSTACK: u32 =3D 134217728; +pub const SA_RESTART: u32 =3D 268435456; +pub const SA_NODEFER: u32 =3D 1073741824; +pub const SA_RESETHAND: u32 =3D 2147483648; +pub const SA_INTERRUPT: u32 =3D 536870912; +pub const SA_NOMASK: u32 =3D 1073741824; +pub const SA_ONESHOT: u32 =3D 2147483648; +pub const SA_STACK: u32 =3D 134217728; +pub const SIG_BLOCK: u32 =3D 0; +pub const SIG_UNBLOCK: u32 =3D 1; +pub const SIG_SETMASK: u32 =3D 2; +pub const _BITS_SIGCONTEXT_H: u32 =3D 1; +pub const FP_XSTATE_MAGIC1: u32 =3D 1179670611; +pub const FP_XSTATE_MAGIC2: u32 =3D 1179670597; +pub const __stack_t_defined: u32 =3D 1; +pub const _SYS_UCONTEXT_H: u32 =3D 1; +pub const __NGREG: u32 =3D 23; +pub const NGREG: u32 =3D 23; +pub const _BITS_SIGSTACK_H: u32 =3D 1; +pub const MINSIGSTKSZ: u32 =3D 2048; +pub const SIGSTKSZ: u32 =3D 8192; +pub const _BITS_SS_FLAGS_H: u32 =3D 1; +pub const __sigstack_defined: u32 =3D 1; +pub const _BITS_SIGTHREAD_H: u32 =3D 1; +pub const _SYS_UIO_H: u32 =3D 1; +pub const UIO_MAXIOV: u32 =3D 1024; +pub const _BITS_UIO_EXT_H: u32 =3D 1; +pub const RWF_HIPRI: u32 =3D 1; +pub const RWF_DSYNC: u32 =3D 2; +pub const RWF_SYNC: u32 =3D 4; +pub const RWF_NOWAIT: u32 =3D 8; +pub const RWF_APPEND: u32 =3D 16; +pub const _SYS_WAIT_H: u32 =3D 1; +pub const WCOREFLAG: u32 =3D 128; +pub const WAIT_ANY: i32 =3D -1; +pub const WAIT_MYPGRP: u32 =3D 0; +pub const G_ANALYZER_ANALYZING: u32 =3D 0; +pub const FALSE: u32 =3D 0; +#[allow(unsafe_code)] +pub const G_GINT16_MODIFIER: &::core::ffi::CStr =3D + unsafe { ::core::ffi::CStr::from_bytes_with_nul_unchecked(b"h\0") }; +#[allow(unsafe_code)] +pub const G_GINT16_FORMAT: &::core::ffi::CStr =3D + unsafe { ::core::ffi::CStr::from_bytes_with_nul_unchecked(b"hi\0") }; +#[allow(unsafe_code)] +pub const G_GUINT16_FORMAT: &::core::ffi::CStr =3D + unsafe { ::core::ffi::CStr::from_bytes_with_nul_unchecked(b"hu\0") }; +#[allow(unsafe_code)] +pub const G_GINT32_MODIFIER: &::core::ffi::CStr =3D + unsafe { ::core::ffi::CStr::from_bytes_with_nul_unchecked(b"\0") }; +#[allow(unsafe_code)] +pub const G_GINT32_FORMAT: &::core::ffi::CStr =3D + unsafe { ::core::ffi::CStr::from_bytes_with_nul_unchecked(b"i\0") }; +#[allow(unsafe_code)] +pub const G_GUINT32_FORMAT: &::core::ffi::CStr =3D + unsafe { ::core::ffi::CStr::from_bytes_with_nul_unchecked(b"u\0") }; +pub const G_HAVE_GINT64: u32 =3D 1; +#[allow(unsafe_code)] +pub const G_GINT64_MODIFIER: &::core::ffi::CStr =3D + unsafe { ::core::ffi::CStr::from_bytes_with_nul_unchecked(b"l\0") }; +#[allow(unsafe_code)] +pub const G_GINT64_FORMAT: &::core::ffi::CStr =3D + unsafe { ::core::ffi::CStr::from_bytes_with_nul_unchecked(b"li\0") }; +#[allow(unsafe_code)] +pub const G_GUINT64_FORMAT: &::core::ffi::CStr =3D + unsafe { ::core::ffi::CStr::from_bytes_with_nul_unchecked(b"lu\0") }; +pub const GLIB_SIZEOF_VOID_P: u32 =3D 8; +pub const GLIB_SIZEOF_LONG: u32 =3D 8; +pub const GLIB_SIZEOF_SIZE_T: u32 =3D 8; +pub const GLIB_SIZEOF_SSIZE_T: u32 =3D 8; +#[allow(unsafe_code)] +pub const G_GSIZE_MODIFIER: &::core::ffi::CStr =3D + unsafe { ::core::ffi::CStr::from_bytes_with_nul_unchecked(b"l\0") }; +#[allow(unsafe_code)] +pub const G_GSSIZE_MODIFIER: &::core::ffi::CStr =3D + unsafe { ::core::ffi::CStr::from_bytes_with_nul_unchecked(b"l\0") }; +#[allow(unsafe_code)] +pub const G_GSIZE_FORMAT: &::core::ffi::CStr =3D + unsafe { ::core::ffi::CStr::from_bytes_with_nul_unchecked(b"lu\0") }; +#[allow(unsafe_code)] +pub const G_GSSIZE_FORMAT: &::core::ffi::CStr =3D + unsafe { ::core::ffi::CStr::from_bytes_with_nul_unchecked(b"li\0") }; +#[allow(unsafe_code)] +pub const G_GOFFSET_MODIFIER: &::core::ffi::CStr =3D + unsafe { ::core::ffi::CStr::from_bytes_with_nul_unchecked(b"l\0") }; +#[allow(unsafe_code)] +pub const G_GOFFSET_FORMAT: &::core::ffi::CStr =3D + unsafe { ::core::ffi::CStr::from_bytes_with_nul_unchecked(b"li\0") }; +#[allow(unsafe_code)] +pub const G_POLLFD_FORMAT: &::core::ffi::CStr =3D + unsafe { ::core::ffi::CStr::from_bytes_with_nul_unchecked(b"%d\0") }; +#[allow(unsafe_code)] +pub const G_GINTPTR_MODIFIER: &::core::ffi::CStr =3D + unsafe { ::core::ffi::CStr::from_bytes_with_nul_unchecked(b"l\0") }; +#[allow(unsafe_code)] +pub const G_GINTPTR_FORMAT: &::core::ffi::CStr =3D + unsafe { ::core::ffi::CStr::from_bytes_with_nul_unchecked(b"li\0") }; +#[allow(unsafe_code)] +pub const G_GUINTPTR_FORMAT: &::core::ffi::CStr =3D + unsafe { ::core::ffi::CStr::from_bytes_with_nul_unchecked(b"lu\0") }; +pub const GLIB_MAJOR_VERSION: u32 =3D 2; +pub const GLIB_MINOR_VERSION: u32 =3D 74; +pub const GLIB_MICRO_VERSION: u32 =3D 6; +pub const G_VA_COPY_AS_ARRAY: u32 =3D 1; +pub const G_HAVE_ISO_VARARGS: u32 =3D 1; +pub const G_HAVE_GROWING_STACK: u32 =3D 0; +pub const G_HAVE_GNUC_VISIBILITY: u32 =3D 1; +pub const G_HAVE_GNUC_VARARGS: u32 =3D 1; +#[allow(unsafe_code)] +pub const G_MODULE_SUFFIX: &::core::ffi::CStr =3D + unsafe { ::core::ffi::CStr::from_bytes_with_nul_unchecked(b"so\0") }; +#[allow(unsafe_code)] +pub const G_PID_FORMAT: &::core::ffi::CStr =3D + unsafe { ::core::ffi::CStr::from_bytes_with_nul_unchecked(b"i\0") }; +pub const GLIB_SYSDEF_AF_UNIX: u32 =3D 1; +pub const GLIB_SYSDEF_AF_INET: u32 =3D 2; +pub const GLIB_SYSDEF_AF_INET6: u32 =3D 10; +pub const GLIB_SYSDEF_MSG_OOB: u32 =3D 1; +pub const GLIB_SYSDEF_MSG_PEEK: u32 =3D 2; +pub const GLIB_SYSDEF_MSG_DONTROUTE: u32 =3D 4; +pub const G_DIR_SEPARATOR: u8 =3D 47u8; +#[allow(unsafe_code)] +pub const G_DIR_SEPARATOR_S: &::core::ffi::CStr =3D + unsafe { ::core::ffi::CStr::from_bytes_with_nul_unchecked(b"/\0") }; +pub const G_SEARCHPATH_SEPARATOR: u8 =3D 58u8; +#[allow(unsafe_code)] +pub const G_SEARCHPATH_SEPARATOR_S: &::core::ffi::CStr =3D + unsafe { ::core::ffi::CStr::from_bytes_with_nul_unchecked(b":\0") }; +pub const G_E: f64 =3D 2.718281828459045; +pub const G_LN2: f64 =3D 0.6931471805599453; +pub const G_LN10: f64 =3D 2.302585092994046; +pub const G_PI: f64 =3D 3.141592653589793; +pub const G_PI_2: f64 =3D 1.5707963267948966; +pub const G_PI_4: f64 =3D 0.7853981633974483; +pub const G_SQRT2: f64 =3D 1.4142135623730951; +pub const G_LITTLE_ENDIAN: u32 =3D 1234; +pub const G_BIG_ENDIAN: u32 =3D 4321; +pub const G_PDP_ENDIAN: u32 =3D 3412; +pub const G_IEEE754_FLOAT_BIAS: u32 =3D 127; +pub const G_IEEE754_DOUBLE_BIAS: u32 =3D 1023; +pub const G_LOG_2_BASE_10: f64 =3D 0.3010299956639812; +pub const G_DATALIST_FLAGS_MASK: u32 =3D 3; +pub const G_DATE_BAD_JULIAN: u32 =3D 0; +pub const G_DATE_BAD_DAY: u32 =3D 0; +pub const G_DATE_BAD_YEAR: u32 =3D 0; +pub const _DIRENT_H: u32 =3D 1; +pub const _DIRENT_MATCHES_DIRENT64: u32 =3D 1; +pub const MAXNAMLEN: u32 =3D 255; +pub const G_MEM_ALIGN: u32 =3D 8; +pub const G_HOOK_FLAG_USER_SHIFT: u32 =3D 4; +pub const G_PRIORITY_HIGH: i32 =3D -100; +pub const G_PRIORITY_DEFAULT: u32 =3D 0; +pub const G_PRIORITY_HIGH_IDLE: u32 =3D 100; +pub const G_PRIORITY_DEFAULT_IDLE: u32 =3D 200; +pub const G_PRIORITY_LOW: u32 =3D 300; +pub const G_SOURCE_REMOVE: u32 =3D 0; +pub const G_UNICHAR_MAX_DECOMPOSITION_LENGTH: u32 =3D 18; +#[allow(unsafe_code)] +pub const G_KEY_FILE_DESKTOP_GROUP: &::core::ffi::CStr =3D + unsafe { ::core::ffi::CStr::from_bytes_with_nul_unchecked(b"Desktop En= try\0") }; +#[allow(unsafe_code)] +pub const G_KEY_FILE_DESKTOP_KEY_TYPE: &::core::ffi::CStr =3D + unsafe { ::core::ffi::CStr::from_bytes_with_nul_unchecked(b"Type\0") }; +#[allow(unsafe_code)] +pub const G_KEY_FILE_DESKTOP_KEY_VERSION: &::core::ffi::CStr =3D + unsafe { ::core::ffi::CStr::from_bytes_with_nul_unchecked(b"Version\0"= ) }; +#[allow(unsafe_code)] +pub const G_KEY_FILE_DESKTOP_KEY_NAME: &::core::ffi::CStr =3D + unsafe { ::core::ffi::CStr::from_bytes_with_nul_unchecked(b"Name\0") }; +#[allow(unsafe_code)] +pub const G_KEY_FILE_DESKTOP_KEY_GENERIC_NAME: &::core::ffi::CStr =3D + unsafe { ::core::ffi::CStr::from_bytes_with_nul_unchecked(b"GenericNam= e\0") }; +#[allow(unsafe_code)] +pub const G_KEY_FILE_DESKTOP_KEY_NO_DISPLAY: &::core::ffi::CStr =3D + unsafe { ::core::ffi::CStr::from_bytes_with_nul_unchecked(b"NoDisplay\= 0") }; +#[allow(unsafe_code)] +pub const G_KEY_FILE_DESKTOP_KEY_COMMENT: &::core::ffi::CStr =3D + unsafe { ::core::ffi::CStr::from_bytes_with_nul_unchecked(b"Comment\0"= ) }; +#[allow(unsafe_code)] +pub const G_KEY_FILE_DESKTOP_KEY_ICON: &::core::ffi::CStr =3D + unsafe { ::core::ffi::CStr::from_bytes_with_nul_unchecked(b"Icon\0") }; +#[allow(unsafe_code)] +pub const G_KEY_FILE_DESKTOP_KEY_HIDDEN: &::core::ffi::CStr =3D + unsafe { ::core::ffi::CStr::from_bytes_with_nul_unchecked(b"Hidden\0")= }; +#[allow(unsafe_code)] +pub const G_KEY_FILE_DESKTOP_KEY_ONLY_SHOW_IN: &::core::ffi::CStr =3D + unsafe { ::core::ffi::CStr::from_bytes_with_nul_unchecked(b"OnlyShowIn= \0") }; +#[allow(unsafe_code)] +pub const G_KEY_FILE_DESKTOP_KEY_NOT_SHOW_IN: &::core::ffi::CStr =3D + unsafe { ::core::ffi::CStr::from_bytes_with_nul_unchecked(b"NotShowIn\= 0") }; +#[allow(unsafe_code)] +pub const G_KEY_FILE_DESKTOP_KEY_TRY_EXEC: &::core::ffi::CStr =3D + unsafe { ::core::ffi::CStr::from_bytes_with_nul_unchecked(b"TryExec\0"= ) }; +#[allow(unsafe_code)] +pub const G_KEY_FILE_DESKTOP_KEY_EXEC: &::core::ffi::CStr =3D + unsafe { ::core::ffi::CStr::from_bytes_with_nul_unchecked(b"Exec\0") }; +#[allow(unsafe_code)] +pub const G_KEY_FILE_DESKTOP_KEY_PATH: &::core::ffi::CStr =3D + unsafe { ::core::ffi::CStr::from_bytes_with_nul_unchecked(b"Path\0") }; +#[allow(unsafe_code)] +pub const G_KEY_FILE_DESKTOP_KEY_TERMINAL: &::core::ffi::CStr =3D + unsafe { ::core::ffi::CStr::from_bytes_with_nul_unchecked(b"Terminal\0= ") }; +#[allow(unsafe_code)] +pub const G_KEY_FILE_DESKTOP_KEY_MIME_TYPE: &::core::ffi::CStr =3D + unsafe { ::core::ffi::CStr::from_bytes_with_nul_unchecked(b"MimeType\0= ") }; +#[allow(unsafe_code)] +pub const G_KEY_FILE_DESKTOP_KEY_CATEGORIES: &::core::ffi::CStr =3D + unsafe { ::core::ffi::CStr::from_bytes_with_nul_unchecked(b"Categories= \0") }; +#[allow(unsafe_code)] +pub const G_KEY_FILE_DESKTOP_KEY_STARTUP_NOTIFY: &::core::ffi::CStr =3D + unsafe { ::core::ffi::CStr::from_bytes_with_nul_unchecked(b"StartupNot= ify\0") }; +#[allow(unsafe_code)] +pub const G_KEY_FILE_DESKTOP_KEY_STARTUP_WM_CLASS: &::core::ffi::CStr =3D + unsafe { ::core::ffi::CStr::from_bytes_with_nul_unchecked(b"StartupWMC= lass\0") }; +#[allow(unsafe_code)] +pub const G_KEY_FILE_DESKTOP_KEY_URL: &::core::ffi::CStr =3D + unsafe { ::core::ffi::CStr::from_bytes_with_nul_unchecked(b"URL\0") }; +#[allow(unsafe_code)] +pub const G_KEY_FILE_DESKTOP_KEY_DBUS_ACTIVATABLE: &::core::ffi::CStr =3D + unsafe { ::core::ffi::CStr::from_bytes_with_nul_unchecked(b"DBusActiva= table\0") }; +#[allow(unsafe_code)] +pub const G_KEY_FILE_DESKTOP_KEY_ACTIONS: &::core::ffi::CStr =3D + unsafe { ::core::ffi::CStr::from_bytes_with_nul_unchecked(b"Actions\0"= ) }; +#[allow(unsafe_code)] +pub const G_KEY_FILE_DESKTOP_TYPE_APPLICATION: &::core::ffi::CStr =3D + unsafe { ::core::ffi::CStr::from_bytes_with_nul_unchecked(b"Applicatio= n\0") }; +#[allow(unsafe_code)] +pub const G_KEY_FILE_DESKTOP_TYPE_LINK: &::core::ffi::CStr =3D + unsafe { ::core::ffi::CStr::from_bytes_with_nul_unchecked(b"Link\0") }; +#[allow(unsafe_code)] +pub const G_KEY_FILE_DESKTOP_TYPE_DIRECTORY: &::core::ffi::CStr =3D + unsafe { ::core::ffi::CStr::from_bytes_with_nul_unchecked(b"Directory\= 0") }; +pub const G_LOG_LEVEL_USER_SHIFT: u32 =3D 8; +#[allow(unsafe_code)] +pub const G_OPTION_REMAINING: &::core::ffi::CStr =3D + unsafe { ::core::ffi::CStr::from_bytes_with_nul_unchecked(b"\0") }; +#[allow(unsafe_code)] +pub const G_CSET_A_2_Z: &::core::ffi::CStr =3D + unsafe { ::core::ffi::CStr::from_bytes_with_nul_unchecked(b"ABCDEFGHIJ= KLMNOPQRSTUVWXYZ\0") }; +#[allow(unsafe_code)] +pub const G_CSET_a_2_z: &::core::ffi::CStr =3D + unsafe { ::core::ffi::CStr::from_bytes_with_nul_unchecked(b"abcdefghij= klmnopqrstuvwxyz\0") }; +#[allow(unsafe_code)] +pub const G_CSET_DIGITS: &::core::ffi::CStr =3D + unsafe { ::core::ffi::CStr::from_bytes_with_nul_unchecked(b"0123456789= \0") }; +#[allow(unsafe_code)] +pub const G_CSET_LATINC: &::core::ffi::CStr =3D unsafe { + :: core :: ffi :: CStr :: from_bytes_with_nul_unchecked (b"\xC0\xC1\xC= 2\xC3\xC4\xC5\xC6\xC7\xC8\xC9\xCA\xCB\xCC\xCD\xCE\xCF\xD0\xD1\xD2\xD3\xD4\x= D5\xD6\xD8\xD9\xDA\xDB\xDC\xDD\xDE\0") +}; +#[allow(unsafe_code)] +pub const G_CSET_LATINS: &::core::ffi::CStr =3D unsafe { + :: core :: ffi :: CStr :: from_bytes_with_nul_unchecked (b"\xDF\xE0\xE= 1\xE2\xE3\xE4\xE5\xE6\xE7\xE8\xE9\xEA\xEB\xEC\xED\xEE\xEF\xF0\xF1\xF2\xF3\x= F4\xF5\xF6\xF8\xF9\xFA\xFB\xFC\xFD\xFE\xFF\0") +}; +#[allow(unsafe_code)] +pub const G_STR_DELIMITERS: &::core::ffi::CStr =3D + unsafe { ::core::ffi::CStr::from_bytes_with_nul_unchecked(b"_-|> <.\0"= ) }; +pub const G_ASCII_DTOSTR_BUF_SIZE: u32 =3D 39; +#[allow(unsafe_code)] +pub const G_TEST_OPTION_ISOLATE_DIRS: &::core::ffi::CStr =3D + unsafe { ::core::ffi::CStr::from_bytes_with_nul_unchecked(b"isolate_di= rs\0") }; +pub const G_USEC_PER_SEC: u32 =3D 1000000; +#[allow(unsafe_code)] +pub const G_URI_RESERVED_CHARS_GENERIC_DELIMITERS: &::core::ffi::CStr =3D + unsafe { ::core::ffi::CStr::from_bytes_with_nul_unchecked(b":/?#[]@\0"= ) }; +#[allow(unsafe_code)] +pub const G_URI_RESERVED_CHARS_SUBCOMPONENT_DELIMITERS: &::core::ffi::CStr= =3D + unsafe { ::core::ffi::CStr::from_bytes_with_nul_unchecked(b"!$&'()*+,;= =3D\0") }; +#[allow(unsafe_code)] +pub const G_URI_RESERVED_CHARS_ALLOWED_IN_PATH_ELEMENT: &::core::ffi::CStr= =3D + unsafe { ::core::ffi::CStr::from_bytes_with_nul_unchecked(b"!$&'()*+,;= =3D:@\0") }; +#[allow(unsafe_code)] +pub const G_URI_RESERVED_CHARS_ALLOWED_IN_PATH: &::core::ffi::CStr =3D + unsafe { ::core::ffi::CStr::from_bytes_with_nul_unchecked(b"!$&'()*+,;= =3D:@/\0") }; +#[allow(unsafe_code)] +pub const G_URI_RESERVED_CHARS_ALLOWED_IN_USERINFO: &::core::ffi::CStr =3D + unsafe { ::core::ffi::CStr::from_bytes_with_nul_unchecked(b"!$&'()*+,;= =3D:\0") }; +pub const G_ALLOC_ONLY: u32 =3D 1; +pub const G_ALLOC_AND_FREE: u32 =3D 2; +pub const G_ALLOCATOR_LIST: u32 =3D 1; +pub const G_ALLOCATOR_SLIST: u32 =3D 2; +pub const G_ALLOCATOR_NODE: u32 =3D 3; +pub const _PTHREAD_H: u32 =3D 1; +pub const _SCHED_H: u32 =3D 1; +pub const _BITS_SCHED_H: u32 =3D 1; +pub const SCHED_OTHER: u32 =3D 0; +pub const SCHED_FIFO: u32 =3D 1; +pub const SCHED_RR: u32 =3D 2; +pub const SCHED_BATCH: u32 =3D 3; +pub const SCHED_ISO: u32 =3D 4; +pub const SCHED_IDLE: u32 =3D 5; +pub const SCHED_DEADLINE: u32 =3D 6; +pub const SCHED_RESET_ON_FORK: u32 =3D 1073741824; +pub const CSIGNAL: u32 =3D 255; +pub const CLONE_VM: u32 =3D 256; +pub const CLONE_FS: u32 =3D 512; +pub const CLONE_FILES: u32 =3D 1024; +pub const CLONE_SIGHAND: u32 =3D 2048; +pub const CLONE_PIDFD: u32 =3D 4096; +pub const CLONE_PTRACE: u32 =3D 8192; +pub const CLONE_VFORK: u32 =3D 16384; +pub const CLONE_PARENT: u32 =3D 32768; +pub const CLONE_THREAD: u32 =3D 65536; +pub const CLONE_NEWNS: u32 =3D 131072; +pub const CLONE_SYSVSEM: u32 =3D 262144; +pub const CLONE_SETTLS: u32 =3D 524288; +pub const CLONE_PARENT_SETTID: u32 =3D 1048576; +pub const CLONE_CHILD_CLEARTID: u32 =3D 2097152; +pub const CLONE_DETACHED: u32 =3D 4194304; +pub const CLONE_UNTRACED: u32 =3D 8388608; +pub const CLONE_CHILD_SETTID: u32 =3D 16777216; +pub const CLONE_NEWCGROUP: u32 =3D 33554432; +pub const CLONE_NEWUTS: u32 =3D 67108864; +pub const CLONE_NEWIPC: u32 =3D 134217728; +pub const CLONE_NEWUSER: u32 =3D 268435456; +pub const CLONE_NEWPID: u32 =3D 536870912; +pub const CLONE_NEWNET: u32 =3D 1073741824; +pub const CLONE_IO: u32 =3D 2147483648; +pub const CLONE_NEWTIME: u32 =3D 128; +pub const _BITS_TYPES_STRUCT_SCHED_PARAM: u32 =3D 1; +pub const _BITS_CPU_SET_H: u32 =3D 1; +pub const __CPU_SETSIZE: u32 =3D 1024; +pub const CPU_SETSIZE: u32 =3D 1024; +pub const PTHREAD_ONCE_INIT: u32 =3D 0; +pub const PTHREAD_BARRIER_SERIAL_THREAD: i32 =3D -1; +pub const PTHREAD_ATTR_NO_SIGMASK_NP: i32 =3D -1; +pub const _PWD_H: u32 =3D 1; +pub const NSS_BUFLEN_PASSWD: u32 =3D 1024; +pub const _SYS_MMAN_H: u32 =3D 1; +pub const MAP_32BIT: u32 =3D 64; +pub const MAP_GROWSDOWN: u32 =3D 256; +pub const MAP_DENYWRITE: u32 =3D 2048; +pub const MAP_EXECUTABLE: u32 =3D 4096; +pub const MAP_LOCKED: u32 =3D 8192; +pub const MAP_NORESERVE: u32 =3D 16384; +pub const MAP_POPULATE: u32 =3D 32768; +pub const MAP_NONBLOCK: u32 =3D 65536; +pub const MAP_STACK: u32 =3D 131072; +pub const MAP_HUGETLB: u32 =3D 262144; +pub const MAP_SYNC: u32 =3D 524288; +pub const MAP_FIXED_NOREPLACE: u32 =3D 1048576; +pub const PROT_READ: u32 =3D 1; +pub const PROT_WRITE: u32 =3D 2; +pub const PROT_EXEC: u32 =3D 4; +pub const PROT_NONE: u32 =3D 0; +pub const PROT_GROWSDOWN: u32 =3D 16777216; +pub const PROT_GROWSUP: u32 =3D 33554432; +pub const MAP_SHARED: u32 =3D 1; +pub const MAP_PRIVATE: u32 =3D 2; +pub const MAP_SHARED_VALIDATE: u32 =3D 3; +pub const MAP_TYPE: u32 =3D 15; +pub const MAP_FIXED: u32 =3D 16; +pub const MAP_FILE: u32 =3D 0; +pub const MAP_ANONYMOUS: u32 =3D 32; +pub const MAP_ANON: u32 =3D 32; +pub const MAP_HUGE_SHIFT: u32 =3D 26; +pub const MAP_HUGE_MASK: u32 =3D 63; +pub const MS_ASYNC: u32 =3D 1; +pub const MS_SYNC: u32 =3D 4; +pub const MS_INVALIDATE: u32 =3D 2; +pub const MADV_NORMAL: u32 =3D 0; +pub const MADV_RANDOM: u32 =3D 1; +pub const MADV_SEQUENTIAL: u32 =3D 2; +pub const MADV_WILLNEED: u32 =3D 3; +pub const MADV_DONTNEED: u32 =3D 4; +pub const MADV_FREE: u32 =3D 8; +pub const MADV_REMOVE: u32 =3D 9; +pub const MADV_DONTFORK: u32 =3D 10; +pub const MADV_DOFORK: u32 =3D 11; +pub const MADV_MERGEABLE: u32 =3D 12; +pub const MADV_UNMERGEABLE: u32 =3D 13; +pub const MADV_HUGEPAGE: u32 =3D 14; +pub const MADV_NOHUGEPAGE: u32 =3D 15; +pub const MADV_DONTDUMP: u32 =3D 16; +pub const MADV_DODUMP: u32 =3D 17; +pub const MADV_WIPEONFORK: u32 =3D 18; +pub const MADV_KEEPONFORK: u32 =3D 19; +pub const MADV_COLD: u32 =3D 20; +pub const MADV_PAGEOUT: u32 =3D 21; +pub const MADV_POPULATE_READ: u32 =3D 22; +pub const MADV_POPULATE_WRITE: u32 =3D 23; +pub const MADV_DONTNEED_LOCKED: u32 =3D 24; +pub const MADV_HWPOISON: u32 =3D 100; +pub const POSIX_MADV_NORMAL: u32 =3D 0; +pub const POSIX_MADV_RANDOM: u32 =3D 1; +pub const POSIX_MADV_SEQUENTIAL: u32 =3D 2; +pub const POSIX_MADV_WILLNEED: u32 =3D 3; +pub const POSIX_MADV_DONTNEED: u32 =3D 4; +pub const MCL_CURRENT: u32 =3D 1; +pub const MCL_FUTURE: u32 =3D 2; +pub const MCL_ONFAULT: u32 =3D 4; +pub const MREMAP_MAYMOVE: u32 =3D 1; +pub const MREMAP_FIXED: u32 =3D 2; +pub const MREMAP_DONTUNMAP: u32 =3D 4; +pub const MFD_CLOEXEC: u32 =3D 1; +pub const MFD_ALLOW_SEALING: u32 =3D 2; +pub const MFD_HUGETLB: u32 =3D 4; +pub const MLOCK_ONFAULT: u32 =3D 1; +pub const PKEY_DISABLE_ACCESS: u32 =3D 1; +pub const PKEY_DISABLE_WRITE: u32 =3D 2; +pub const _SYS_SOCKET_H: u32 =3D 1; +pub const PF_UNSPEC: u32 =3D 0; +pub const PF_LOCAL: u32 =3D 1; +pub const PF_UNIX: u32 =3D 1; +pub const PF_FILE: u32 =3D 1; +pub const PF_INET: u32 =3D 2; +pub const PF_AX25: u32 =3D 3; +pub const PF_IPX: u32 =3D 4; +pub const PF_APPLETALK: u32 =3D 5; +pub const PF_NETROM: u32 =3D 6; +pub const PF_BRIDGE: u32 =3D 7; +pub const PF_ATMPVC: u32 =3D 8; +pub const PF_X25: u32 =3D 9; +pub const PF_INET6: u32 =3D 10; +pub const PF_ROSE: u32 =3D 11; +pub const PF_DECnet: u32 =3D 12; +pub const PF_NETBEUI: u32 =3D 13; +pub const PF_SECURITY: u32 =3D 14; +pub const PF_KEY: u32 =3D 15; +pub const PF_NETLINK: u32 =3D 16; +pub const PF_ROUTE: u32 =3D 16; +pub const PF_PACKET: u32 =3D 17; +pub const PF_ASH: u32 =3D 18; +pub const PF_ECONET: u32 =3D 19; +pub const PF_ATMSVC: u32 =3D 20; +pub const PF_RDS: u32 =3D 21; +pub const PF_SNA: u32 =3D 22; +pub const PF_IRDA: u32 =3D 23; +pub const PF_PPPOX: u32 =3D 24; +pub const PF_WANPIPE: u32 =3D 25; +pub const PF_LLC: u32 =3D 26; +pub const PF_IB: u32 =3D 27; +pub const PF_MPLS: u32 =3D 28; +pub const PF_CAN: u32 =3D 29; +pub const PF_TIPC: u32 =3D 30; +pub const PF_BLUETOOTH: u32 =3D 31; +pub const PF_IUCV: u32 =3D 32; +pub const PF_RXRPC: u32 =3D 33; +pub const PF_ISDN: u32 =3D 34; +pub const PF_PHONET: u32 =3D 35; +pub const PF_IEEE802154: u32 =3D 36; +pub const PF_CAIF: u32 =3D 37; +pub const PF_ALG: u32 =3D 38; +pub const PF_NFC: u32 =3D 39; +pub const PF_VSOCK: u32 =3D 40; +pub const PF_KCM: u32 =3D 41; +pub const PF_QIPCRTR: u32 =3D 42; +pub const PF_SMC: u32 =3D 43; +pub const PF_XDP: u32 =3D 44; +pub const PF_MCTP: u32 =3D 45; +pub const PF_MAX: u32 =3D 46; +pub const AF_UNSPEC: u32 =3D 0; +pub const AF_LOCAL: u32 =3D 1; +pub const AF_UNIX: u32 =3D 1; +pub const AF_FILE: u32 =3D 1; +pub const AF_INET: u32 =3D 2; +pub const AF_AX25: u32 =3D 3; +pub const AF_IPX: u32 =3D 4; +pub const AF_APPLETALK: u32 =3D 5; +pub const AF_NETROM: u32 =3D 6; +pub const AF_BRIDGE: u32 =3D 7; +pub const AF_ATMPVC: u32 =3D 8; +pub const AF_X25: u32 =3D 9; +pub const AF_INET6: u32 =3D 10; +pub const AF_ROSE: u32 =3D 11; +pub const AF_DECnet: u32 =3D 12; +pub const AF_NETBEUI: u32 =3D 13; +pub const AF_SECURITY: u32 =3D 14; +pub const AF_KEY: u32 =3D 15; +pub const AF_NETLINK: u32 =3D 16; +pub const AF_ROUTE: u32 =3D 16; +pub const AF_PACKET: u32 =3D 17; +pub const AF_ASH: u32 =3D 18; +pub const AF_ECONET: u32 =3D 19; +pub const AF_ATMSVC: u32 =3D 20; +pub const AF_RDS: u32 =3D 21; +pub const AF_SNA: u32 =3D 22; +pub const AF_IRDA: u32 =3D 23; +pub const AF_PPPOX: u32 =3D 24; +pub const AF_WANPIPE: u32 =3D 25; +pub const AF_LLC: u32 =3D 26; +pub const AF_IB: u32 =3D 27; +pub const AF_MPLS: u32 =3D 28; +pub const AF_CAN: u32 =3D 29; +pub const AF_TIPC: u32 =3D 30; +pub const AF_BLUETOOTH: u32 =3D 31; +pub const AF_IUCV: u32 =3D 32; +pub const AF_RXRPC: u32 =3D 33; +pub const AF_ISDN: u32 =3D 34; +pub const AF_PHONET: u32 =3D 35; +pub const AF_IEEE802154: u32 =3D 36; +pub const AF_CAIF: u32 =3D 37; +pub const AF_ALG: u32 =3D 38; +pub const AF_NFC: u32 =3D 39; +pub const AF_VSOCK: u32 =3D 40; +pub const AF_KCM: u32 =3D 41; +pub const AF_QIPCRTR: u32 =3D 42; +pub const AF_SMC: u32 =3D 43; +pub const AF_XDP: u32 =3D 44; +pub const AF_MCTP: u32 =3D 45; +pub const AF_MAX: u32 =3D 46; +pub const SOL_RAW: u32 =3D 255; +pub const SOL_DECNET: u32 =3D 261; +pub const SOL_X25: u32 =3D 262; +pub const SOL_PACKET: u32 =3D 263; +pub const SOL_ATM: u32 =3D 264; +pub const SOL_AAL: u32 =3D 265; +pub const SOL_IRDA: u32 =3D 266; +pub const SOL_NETBEUI: u32 =3D 267; +pub const SOL_LLC: u32 =3D 268; +pub const SOL_DCCP: u32 =3D 269; +pub const SOL_NETLINK: u32 =3D 270; +pub const SOL_TIPC: u32 =3D 271; +pub const SOL_RXRPC: u32 =3D 272; +pub const SOL_PPPOL2TP: u32 =3D 273; +pub const SOL_BLUETOOTH: u32 =3D 274; +pub const SOL_PNPIPE: u32 =3D 275; +pub const SOL_RDS: u32 =3D 276; +pub const SOL_IUCV: u32 =3D 277; +pub const SOL_CAIF: u32 =3D 278; +pub const SOL_ALG: u32 =3D 279; +pub const SOL_NFC: u32 =3D 280; +pub const SOL_KCM: u32 =3D 281; +pub const SOL_TLS: u32 =3D 282; +pub const SOL_XDP: u32 =3D 283; +pub const SOL_MPTCP: u32 =3D 284; +pub const SOL_MCTP: u32 =3D 285; +pub const SOL_SMC: u32 =3D 286; +pub const SOMAXCONN: u32 =3D 4096; +pub const _BITS_SOCKADDR_H: u32 =3D 1; +pub const _SS_SIZE: u32 =3D 128; +pub const FIOSETOWN: u32 =3D 35073; +pub const SIOCSPGRP: u32 =3D 35074; +pub const FIOGETOWN: u32 =3D 35075; +pub const SIOCGPGRP: u32 =3D 35076; +pub const SIOCATMARK: u32 =3D 35077; +pub const SIOCGSTAMP_OLD: u32 =3D 35078; +pub const SIOCGSTAMPNS_OLD: u32 =3D 35079; +pub const SOL_SOCKET: u32 =3D 1; +pub const SO_DEBUG: u32 =3D 1; +pub const SO_REUSEADDR: u32 =3D 2; +pub const SO_TYPE: u32 =3D 3; +pub const SO_ERROR: u32 =3D 4; +pub const SO_DONTROUTE: u32 =3D 5; +pub const SO_BROADCAST: u32 =3D 6; +pub const SO_SNDBUF: u32 =3D 7; +pub const SO_RCVBUF: u32 =3D 8; +pub const SO_SNDBUFFORCE: u32 =3D 32; +pub const SO_RCVBUFFORCE: u32 =3D 33; +pub const SO_KEEPALIVE: u32 =3D 9; +pub const SO_OOBINLINE: u32 =3D 10; +pub const SO_NO_CHECK: u32 =3D 11; +pub const SO_PRIORITY: u32 =3D 12; +pub const SO_LINGER: u32 =3D 13; +pub const SO_BSDCOMPAT: u32 =3D 14; +pub const SO_REUSEPORT: u32 =3D 15; +pub const SO_PASSCRED: u32 =3D 16; +pub const SO_PEERCRED: u32 =3D 17; +pub const SO_RCVLOWAT: u32 =3D 18; +pub const SO_SNDLOWAT: u32 =3D 19; +pub const SO_RCVTIMEO_OLD: u32 =3D 20; +pub const SO_SNDTIMEO_OLD: u32 =3D 21; +pub const SO_SECURITY_AUTHENTICATION: u32 =3D 22; +pub const SO_SECURITY_ENCRYPTION_TRANSPORT: u32 =3D 23; +pub const SO_SECURITY_ENCRYPTION_NETWORK: u32 =3D 24; +pub const SO_BINDTODEVICE: u32 =3D 25; +pub const SO_ATTACH_FILTER: u32 =3D 26; +pub const SO_DETACH_FILTER: u32 =3D 27; +pub const SO_GET_FILTER: u32 =3D 26; +pub const SO_PEERNAME: u32 =3D 28; +pub const SO_ACCEPTCONN: u32 =3D 30; +pub const SO_PEERSEC: u32 =3D 31; +pub const SO_PASSSEC: u32 =3D 34; +pub const SO_MARK: u32 =3D 36; +pub const SO_PROTOCOL: u32 =3D 38; +pub const SO_DOMAIN: u32 =3D 39; +pub const SO_RXQ_OVFL: u32 =3D 40; +pub const SO_WIFI_STATUS: u32 =3D 41; +pub const SCM_WIFI_STATUS: u32 =3D 41; +pub const SO_PEEK_OFF: u32 =3D 42; +pub const SO_NOFCS: u32 =3D 43; +pub const SO_LOCK_FILTER: u32 =3D 44; +pub const SO_SELECT_ERR_QUEUE: u32 =3D 45; +pub const SO_BUSY_POLL: u32 =3D 46; +pub const SO_MAX_PACING_RATE: u32 =3D 47; +pub const SO_BPF_EXTENSIONS: u32 =3D 48; +pub const SO_INCOMING_CPU: u32 =3D 49; +pub const SO_ATTACH_BPF: u32 =3D 50; +pub const SO_DETACH_BPF: u32 =3D 27; +pub const SO_ATTACH_REUSEPORT_CBPF: u32 =3D 51; +pub const SO_ATTACH_REUSEPORT_EBPF: u32 =3D 52; +pub const SO_CNX_ADVICE: u32 =3D 53; +pub const SCM_TIMESTAMPING_OPT_STATS: u32 =3D 54; +pub const SO_MEMINFO: u32 =3D 55; +pub const SO_INCOMING_NAPI_ID: u32 =3D 56; +pub const SO_COOKIE: u32 =3D 57; +pub const SCM_TIMESTAMPING_PKTINFO: u32 =3D 58; +pub const SO_PEERGROUPS: u32 =3D 59; +pub const SO_ZEROCOPY: u32 =3D 60; +pub const SO_TXTIME: u32 =3D 61; +pub const SCM_TXTIME: u32 =3D 61; +pub const SO_BINDTOIFINDEX: u32 =3D 62; +pub const SO_TIMESTAMP_OLD: u32 =3D 29; +pub const SO_TIMESTAMPNS_OLD: u32 =3D 35; +pub const SO_TIMESTAMPING_OLD: u32 =3D 37; +pub const SO_TIMESTAMP_NEW: u32 =3D 63; +pub const SO_TIMESTAMPNS_NEW: u32 =3D 64; +pub const SO_TIMESTAMPING_NEW: u32 =3D 65; +pub const SO_RCVTIMEO_NEW: u32 =3D 66; +pub const SO_SNDTIMEO_NEW: u32 =3D 67; +pub const SO_DETACH_REUSEPORT_BPF: u32 =3D 68; +pub const SO_PREFER_BUSY_POLL: u32 =3D 69; +pub const SO_BUSY_POLL_BUDGET: u32 =3D 70; +pub const SO_NETNS_COOKIE: u32 =3D 71; +pub const SO_BUF_LOCK: u32 =3D 72; +pub const SO_RESERVE_MEM: u32 =3D 73; +pub const SO_TXREHASH: u32 =3D 74; +pub const SO_RCVMARK: u32 =3D 75; +pub const SO_TIMESTAMP: u32 =3D 29; +pub const SO_TIMESTAMPNS: u32 =3D 35; +pub const SO_TIMESTAMPING: u32 =3D 37; +pub const SO_RCVTIMEO: u32 =3D 20; +pub const SO_SNDTIMEO: u32 =3D 21; +pub const SCM_TIMESTAMP: u32 =3D 29; +pub const SCM_TIMESTAMPNS: u32 =3D 35; +pub const SCM_TIMESTAMPING: u32 =3D 37; +pub const __osockaddr_defined: u32 =3D 1; +pub const _NETINET_IN_H: u32 =3D 1; +pub const __USE_KERNEL_IPV6_DEFS: u32 =3D 0; +pub const IP_OPTIONS: u32 =3D 4; +pub const IP_HDRINCL: u32 =3D 3; +pub const IP_TOS: u32 =3D 1; +pub const IP_TTL: u32 =3D 2; +pub const IP_RECVOPTS: u32 =3D 6; +pub const IP_RETOPTS: u32 =3D 7; +pub const IP_MULTICAST_IF: u32 =3D 32; +pub const IP_MULTICAST_TTL: u32 =3D 33; +pub const IP_MULTICAST_LOOP: u32 =3D 34; +pub const IP_ADD_MEMBERSHIP: u32 =3D 35; +pub const IP_DROP_MEMBERSHIP: u32 =3D 36; +pub const IP_UNBLOCK_SOURCE: u32 =3D 37; +pub const IP_BLOCK_SOURCE: u32 =3D 38; +pub const IP_ADD_SOURCE_MEMBERSHIP: u32 =3D 39; +pub const IP_DROP_SOURCE_MEMBERSHIP: u32 =3D 40; +pub const IP_MSFILTER: u32 =3D 41; +pub const MCAST_JOIN_GROUP: u32 =3D 42; +pub const MCAST_BLOCK_SOURCE: u32 =3D 43; +pub const MCAST_UNBLOCK_SOURCE: u32 =3D 44; +pub const MCAST_LEAVE_GROUP: u32 =3D 45; +pub const MCAST_JOIN_SOURCE_GROUP: u32 =3D 46; +pub const MCAST_LEAVE_SOURCE_GROUP: u32 =3D 47; +pub const MCAST_MSFILTER: u32 =3D 48; +pub const IP_MULTICAST_ALL: u32 =3D 49; +pub const IP_UNICAST_IF: u32 =3D 50; +pub const MCAST_EXCLUDE: u32 =3D 0; +pub const MCAST_INCLUDE: u32 =3D 1; +pub const IP_ROUTER_ALERT: u32 =3D 5; +pub const IP_PKTINFO: u32 =3D 8; +pub const IP_PKTOPTIONS: u32 =3D 9; +pub const IP_PMTUDISC: u32 =3D 10; +pub const IP_MTU_DISCOVER: u32 =3D 10; +pub const IP_RECVERR: u32 =3D 11; +pub const IP_RECVTTL: u32 =3D 12; +pub const IP_RECVTOS: u32 =3D 13; +pub const IP_MTU: u32 =3D 14; +pub const IP_FREEBIND: u32 =3D 15; +pub const IP_IPSEC_POLICY: u32 =3D 16; +pub const IP_XFRM_POLICY: u32 =3D 17; +pub const IP_PASSSEC: u32 =3D 18; +pub const IP_TRANSPARENT: u32 =3D 19; +pub const IP_ORIGDSTADDR: u32 =3D 20; +pub const IP_RECVORIGDSTADDR: u32 =3D 20; +pub const IP_MINTTL: u32 =3D 21; +pub const IP_NODEFRAG: u32 =3D 22; +pub const IP_CHECKSUM: u32 =3D 23; +pub const IP_BIND_ADDRESS_NO_PORT: u32 =3D 24; +pub const IP_RECVFRAGSIZE: u32 =3D 25; +pub const IP_RECVERR_RFC4884: u32 =3D 26; +pub const IP_PMTUDISC_DONT: u32 =3D 0; +pub const IP_PMTUDISC_WANT: u32 =3D 1; +pub const IP_PMTUDISC_DO: u32 =3D 2; +pub const IP_PMTUDISC_PROBE: u32 =3D 3; +pub const IP_PMTUDISC_INTERFACE: u32 =3D 4; +pub const IP_PMTUDISC_OMIT: u32 =3D 5; +pub const SOL_IP: u32 =3D 0; +pub const IP_DEFAULT_MULTICAST_TTL: u32 =3D 1; +pub const IP_DEFAULT_MULTICAST_LOOP: u32 =3D 1; +pub const IP_MAX_MEMBERSHIPS: u32 =3D 20; +pub const IPV6_ADDRFORM: u32 =3D 1; +pub const IPV6_2292PKTINFO: u32 =3D 2; +pub const IPV6_2292HOPOPTS: u32 =3D 3; +pub const IPV6_2292DSTOPTS: u32 =3D 4; +pub const IPV6_2292RTHDR: u32 =3D 5; +pub const IPV6_2292PKTOPTIONS: u32 =3D 6; +pub const IPV6_CHECKSUM: u32 =3D 7; +pub const IPV6_2292HOPLIMIT: u32 =3D 8; +pub const IPV6_NEXTHOP: u32 =3D 9; +pub const IPV6_AUTHHDR: u32 =3D 10; +pub const IPV6_UNICAST_HOPS: u32 =3D 16; +pub const IPV6_MULTICAST_IF: u32 =3D 17; +pub const IPV6_MULTICAST_HOPS: u32 =3D 18; +pub const IPV6_MULTICAST_LOOP: u32 =3D 19; +pub const IPV6_JOIN_GROUP: u32 =3D 20; +pub const IPV6_LEAVE_GROUP: u32 =3D 21; +pub const IPV6_ROUTER_ALERT: u32 =3D 22; +pub const IPV6_MTU_DISCOVER: u32 =3D 23; +pub const IPV6_MTU: u32 =3D 24; +pub const IPV6_RECVERR: u32 =3D 25; +pub const IPV6_V6ONLY: u32 =3D 26; +pub const IPV6_JOIN_ANYCAST: u32 =3D 27; +pub const IPV6_LEAVE_ANYCAST: u32 =3D 28; +pub const IPV6_MULTICAST_ALL: u32 =3D 29; +pub const IPV6_ROUTER_ALERT_ISOLATE: u32 =3D 30; +pub const IPV6_RECVERR_RFC4884: u32 =3D 31; +pub const IPV6_IPSEC_POLICY: u32 =3D 34; +pub const IPV6_XFRM_POLICY: u32 =3D 35; +pub const IPV6_HDRINCL: u32 =3D 36; +pub const IPV6_RECVPKTINFO: u32 =3D 49; +pub const IPV6_PKTINFO: u32 =3D 50; +pub const IPV6_RECVHOPLIMIT: u32 =3D 51; +pub const IPV6_HOPLIMIT: u32 =3D 52; +pub const IPV6_RECVHOPOPTS: u32 =3D 53; +pub const IPV6_HOPOPTS: u32 =3D 54; +pub const IPV6_RTHDRDSTOPTS: u32 =3D 55; +pub const IPV6_RECVRTHDR: u32 =3D 56; +pub const IPV6_RTHDR: u32 =3D 57; +pub const IPV6_RECVDSTOPTS: u32 =3D 58; +pub const IPV6_DSTOPTS: u32 =3D 59; +pub const IPV6_RECVPATHMTU: u32 =3D 60; +pub const IPV6_PATHMTU: u32 =3D 61; +pub const IPV6_DONTFRAG: u32 =3D 62; +pub const IPV6_RECVTCLASS: u32 =3D 66; +pub const IPV6_TCLASS: u32 =3D 67; +pub const IPV6_AUTOFLOWLABEL: u32 =3D 70; +pub const IPV6_ADDR_PREFERENCES: u32 =3D 72; +pub const IPV6_MINHOPCOUNT: u32 =3D 73; +pub const IPV6_ORIGDSTADDR: u32 =3D 74; +pub const IPV6_RECVORIGDSTADDR: u32 =3D 74; +pub const IPV6_TRANSPARENT: u32 =3D 75; +pub const IPV6_UNICAST_IF: u32 =3D 76; +pub const IPV6_RECVFRAGSIZE: u32 =3D 77; +pub const IPV6_FREEBIND: u32 =3D 78; +pub const IPV6_ADD_MEMBERSHIP: u32 =3D 20; +pub const IPV6_DROP_MEMBERSHIP: u32 =3D 21; +pub const IPV6_RXHOPOPTS: u32 =3D 54; +pub const IPV6_RXDSTOPTS: u32 =3D 59; +pub const IPV6_PMTUDISC_DONT: u32 =3D 0; +pub const IPV6_PMTUDISC_WANT: u32 =3D 1; +pub const IPV6_PMTUDISC_DO: u32 =3D 2; +pub const IPV6_PMTUDISC_PROBE: u32 =3D 3; +pub const IPV6_PMTUDISC_INTERFACE: u32 =3D 4; +pub const IPV6_PMTUDISC_OMIT: u32 =3D 5; +pub const SOL_IPV6: u32 =3D 41; +pub const SOL_ICMPV6: u32 =3D 58; +pub const IPV6_RTHDR_LOOSE: u32 =3D 0; +pub const IPV6_RTHDR_STRICT: u32 =3D 1; +pub const IPV6_RTHDR_TYPE_0: u32 =3D 0; +pub const IN_CLASSA_NET: u32 =3D 4278190080; +pub const IN_CLASSA_NSHIFT: u32 =3D 24; +pub const IN_CLASSA_HOST: u32 =3D 16777215; +pub const IN_CLASSA_MAX: u32 =3D 128; +pub const IN_CLASSB_NET: u32 =3D 4294901760; +pub const IN_CLASSB_NSHIFT: u32 =3D 16; +pub const IN_CLASSB_HOST: u32 =3D 65535; +pub const IN_CLASSB_MAX: u32 =3D 65536; +pub const IN_CLASSC_NET: u32 =3D 4294967040; +pub const IN_CLASSC_NSHIFT: u32 =3D 8; +pub const IN_CLASSC_HOST: u32 =3D 255; +pub const IN_LOOPBACKNET: u32 =3D 127; +pub const INET_ADDRSTRLEN: u32 =3D 16; +pub const INET6_ADDRSTRLEN: u32 =3D 46; +pub const _NETINET_TCP_H: u32 =3D 1; +pub const TCP_NODELAY: u32 =3D 1; +pub const TCP_MAXSEG: u32 =3D 2; +pub const TCP_CORK: u32 =3D 3; +pub const TCP_KEEPIDLE: u32 =3D 4; +pub const TCP_KEEPINTVL: u32 =3D 5; +pub const TCP_KEEPCNT: u32 =3D 6; +pub const TCP_SYNCNT: u32 =3D 7; +pub const TCP_LINGER2: u32 =3D 8; +pub const TCP_DEFER_ACCEPT: u32 =3D 9; +pub const TCP_WINDOW_CLAMP: u32 =3D 10; +pub const TCP_INFO: u32 =3D 11; +pub const TCP_QUICKACK: u32 =3D 12; +pub const TCP_CONGESTION: u32 =3D 13; +pub const TCP_MD5SIG: u32 =3D 14; +pub const TCP_COOKIE_TRANSACTIONS: u32 =3D 15; +pub const TCP_THIN_LINEAR_TIMEOUTS: u32 =3D 16; +pub const TCP_THIN_DUPACK: u32 =3D 17; +pub const TCP_USER_TIMEOUT: u32 =3D 18; +pub const TCP_REPAIR: u32 =3D 19; +pub const TCP_REPAIR_QUEUE: u32 =3D 20; +pub const TCP_QUEUE_SEQ: u32 =3D 21; +pub const TCP_REPAIR_OPTIONS: u32 =3D 22; +pub const TCP_FASTOPEN: u32 =3D 23; +pub const TCP_TIMESTAMP: u32 =3D 24; +pub const TCP_NOTSENT_LOWAT: u32 =3D 25; +pub const TCP_CC_INFO: u32 =3D 26; +pub const TCP_SAVE_SYN: u32 =3D 27; +pub const TCP_SAVED_SYN: u32 =3D 28; +pub const TCP_REPAIR_WINDOW: u32 =3D 29; +pub const TCP_FASTOPEN_CONNECT: u32 =3D 30; +pub const TCP_ULP: u32 =3D 31; +pub const TCP_MD5SIG_EXT: u32 =3D 32; +pub const TCP_FASTOPEN_KEY: u32 =3D 33; +pub const TCP_FASTOPEN_NO_COOKIE: u32 =3D 34; +pub const TCP_ZEROCOPY_RECEIVE: u32 =3D 35; +pub const TCP_INQ: u32 =3D 36; +pub const TCP_CM_INQ: u32 =3D 36; +pub const TCP_TX_DELAY: u32 =3D 37; +pub const TCP_REPAIR_ON: u32 =3D 1; +pub const TCP_REPAIR_OFF: u32 =3D 0; +pub const TCP_REPAIR_OFF_NO_WP: i32 =3D -1; +pub const TH_FIN: u32 =3D 1; +pub const TH_SYN: u32 =3D 2; +pub const TH_RST: u32 =3D 4; +pub const TH_PUSH: u32 =3D 8; +pub const TH_ACK: u32 =3D 16; +pub const TH_URG: u32 =3D 32; +pub const TCPOPT_EOL: u32 =3D 0; +pub const TCPOPT_NOP: u32 =3D 1; +pub const TCPOPT_MAXSEG: u32 =3D 2; +pub const TCPOLEN_MAXSEG: u32 =3D 4; +pub const TCPOPT_WINDOW: u32 =3D 3; +pub const TCPOLEN_WINDOW: u32 =3D 3; +pub const TCPOPT_SACK_PERMITTED: u32 =3D 4; +pub const TCPOLEN_SACK_PERMITTED: u32 =3D 2; +pub const TCPOPT_SACK: u32 =3D 5; +pub const TCPOPT_TIMESTAMP: u32 =3D 8; +pub const TCPOLEN_TIMESTAMP: u32 =3D 10; +pub const TCPOLEN_TSTAMP_APPA: u32 =3D 12; +pub const TCPOPT_TSTAMP_HDR: u32 =3D 16844810; +pub const TCP_MSS: u32 =3D 512; +pub const TCP_MAXWIN: u32 =3D 65535; +pub const TCP_MAX_WINSHIFT: u32 =3D 14; +pub const SOL_TCP: u32 =3D 6; +pub const TCPI_OPT_TIMESTAMPS: u32 =3D 1; +pub const TCPI_OPT_SACK: u32 =3D 2; +pub const TCPI_OPT_WSCALE: u32 =3D 4; +pub const TCPI_OPT_ECN: u32 =3D 8; +pub const TCPI_OPT_ECN_SEEN: u32 =3D 16; +pub const TCPI_OPT_SYN_DATA: u32 =3D 32; +pub const TCP_MD5SIG_MAXKEYLEN: u32 =3D 80; +pub const TCP_MD5SIG_FLAG_PREFIX: u32 =3D 1; +pub const TCP_COOKIE_MIN: u32 =3D 8; +pub const TCP_COOKIE_MAX: u32 =3D 16; +pub const TCP_COOKIE_PAIR_SIZE: u32 =3D 32; +pub const TCP_COOKIE_IN_ALWAYS: u32 =3D 1; +pub const TCP_COOKIE_OUT_NEVER: u32 =3D 2; +pub const TCP_S_DATA_IN: u32 =3D 4; +pub const TCP_S_DATA_OUT: u32 =3D 8; +pub const TCP_MSS_DEFAULT: u32 =3D 536; +pub const TCP_MSS_DESIRED: u32 =3D 1220; +pub const _ARPA_INET_H: u32 =3D 1; +pub const _NETDB_H: u32 =3D 1; +pub const _RPC_NETDB_H: u32 =3D 1; +#[allow(unsafe_code)] +pub const _PATH_HEQUIV: &::core::ffi::CStr =3D + unsafe { ::core::ffi::CStr::from_bytes_with_nul_unchecked(b"/etc/hosts= .equiv\0") }; +#[allow(unsafe_code)] +pub const _PATH_HOSTS: &::core::ffi::CStr =3D + unsafe { ::core::ffi::CStr::from_bytes_with_nul_unchecked(b"/etc/hosts= \0") }; +#[allow(unsafe_code)] +pub const _PATH_NETWORKS: &::core::ffi::CStr =3D + unsafe { ::core::ffi::CStr::from_bytes_with_nul_unchecked(b"/etc/netwo= rks\0") }; +#[allow(unsafe_code)] +pub const _PATH_NSSWITCH_CONF: &::core::ffi::CStr =3D + unsafe { ::core::ffi::CStr::from_bytes_with_nul_unchecked(b"/etc/nsswi= tch.conf\0") }; +#[allow(unsafe_code)] +pub const _PATH_PROTOCOLS: &::core::ffi::CStr =3D + unsafe { ::core::ffi::CStr::from_bytes_with_nul_unchecked(b"/etc/proto= cols\0") }; +#[allow(unsafe_code)] +pub const _PATH_SERVICES: &::core::ffi::CStr =3D + unsafe { ::core::ffi::CStr::from_bytes_with_nul_unchecked(b"/etc/servi= ces\0") }; +pub const HOST_NOT_FOUND: u32 =3D 1; +pub const TRY_AGAIN: u32 =3D 2; +pub const NO_RECOVERY: u32 =3D 3; +pub const NO_DATA: u32 =3D 4; +pub const NETDB_INTERNAL: i32 =3D -1; +pub const NETDB_SUCCESS: u32 =3D 0; +pub const NO_ADDRESS: u32 =3D 4; +pub const SCOPE_DELIMITER: u8 =3D 37u8; +pub const GAI_WAIT: u32 =3D 0; +pub const GAI_NOWAIT: u32 =3D 1; +pub const AI_PASSIVE: u32 =3D 1; +pub const AI_CANONNAME: u32 =3D 2; +pub const AI_NUMERICHOST: u32 =3D 4; +pub const AI_V4MAPPED: u32 =3D 8; +pub const AI_ALL: u32 =3D 16; +pub const AI_ADDRCONFIG: u32 =3D 32; +pub const AI_IDN: u32 =3D 64; +pub const AI_CANONIDN: u32 =3D 128; +pub const AI_NUMERICSERV: u32 =3D 1024; +pub const EAI_BADFLAGS: i32 =3D -1; +pub const EAI_NONAME: i32 =3D -2; +pub const EAI_AGAIN: i32 =3D -3; +pub const EAI_FAIL: i32 =3D -4; +pub const EAI_FAMILY: i32 =3D -6; +pub const EAI_SOCKTYPE: i32 =3D -7; +pub const EAI_SERVICE: i32 =3D -8; +pub const EAI_MEMORY: i32 =3D -10; +pub const EAI_SYSTEM: i32 =3D -11; +pub const EAI_OVERFLOW: i32 =3D -12; +pub const EAI_NODATA: i32 =3D -5; +pub const EAI_ADDRFAMILY: i32 =3D -9; +pub const EAI_INPROGRESS: i32 =3D -100; +pub const EAI_CANCELED: i32 =3D -101; +pub const EAI_NOTCANCELED: i32 =3D -102; +pub const EAI_ALLDONE: i32 =3D -103; +pub const EAI_INTR: i32 =3D -104; +pub const EAI_IDN_ENCODE: i32 =3D -105; +pub const NI_MAXHOST: u32 =3D 1025; +pub const NI_MAXSERV: u32 =3D 32; +pub const NI_NUMERICHOST: u32 =3D 1; +pub const NI_NUMERICSERV: u32 =3D 2; +pub const NI_NOFQDN: u32 =3D 4; +pub const NI_NAMEREQD: u32 =3D 8; +pub const NI_DGRAM: u32 =3D 16; +pub const NI_IDN: u32 =3D 32; +pub const _SYS_UN_H: u32 =3D 1; +pub const _SYS_SYSMACROS_H: u32 =3D 1; +pub const _BITS_SYSMACROS_H: u32 =3D 1; +pub const O_BINARY: u32 =3D 0; +pub const HAVE_CHARDEV_SERIAL: u32 =3D 1; +pub const HAVE_CHARDEV_PARALLEL: u32 =3D 1; +pub const QEMU_VMALLOC_ALIGN: u32 =3D 2097152; +#[allow(unsafe_code)] +pub const FMT_pid: &::core::ffi::CStr =3D + unsafe { ::core::ffi::CStr::from_bytes_with_nul_unchecked(b"%d\0") }; +pub const ATOMIC_REG_SIZE: u32 =3D 8; +pub const NANOSECONDS_PER_SECOND: u32 =3D 1000000000; +pub const SCALE_MS: u32 =3D 1000000; +pub const SCALE_US: u32 =3D 1000; +pub const SCALE_NS: u32 =3D 1; +pub const QEMU_TIMER_ATTR_ALL: u32 =3D 4294967295; +#[allow(unsafe_code)] +pub const UUID_FMT: &::core::ffi::CStr =3D unsafe { + :: core :: ffi :: CStr :: from_bytes_with_nul_unchecked (b"%02hhx%02hh= x%02hhx%02hhx-%02hhx%02hhx-%02hhx%02hhx-%02hhx%02hhx-%02hhx%02hhx%02hhx%02h= hx%02hhx%02hhx\0") +}; +#[allow(unsafe_code)] +pub const UUID_NONE: &::core::ffi::CStr =3D unsafe { + ::core::ffi::CStr::from_bytes_with_nul_unchecked(b"00000000-0000-0000-= 0000-000000000000\0") +}; +pub const MAX_OPTION_ROMS: u32 =3D 16; +pub const MAX_PROM_ENVS: u32 =3D 128; +pub const MAX_PARALLEL_PORTS: u32 =3D 3; +pub const _SEMAPHORE_H: u32 =3D 1; +pub const __SIZEOF_SEM_T: u32 =3D 32; +pub const QEMU_THREAD_JOINABLE: u32 =3D 0; +pub const QEMU_THREAD_DETACHED: u32 =3D 1; +#[allow(unsafe_code)] +pub const TYPE_OBJECT: &::core::ffi::CStr =3D + unsafe { ::core::ffi::CStr::from_bytes_with_nul_unchecked(b"object\0")= }; +pub const OBJECT_CLASS_CAST_CACHE: u32 =3D 4; +#[allow(unsafe_code)] +pub const TYPE_INTERFACE: &::core::ffi::CStr =3D + unsafe { ::core::ffi::CStr::from_bytes_with_nul_unchecked(b"interface\= 0") }; +#[allow(unsafe_code)] +pub const TYPE_HOTPLUG_HANDLER: &::core::ffi::CStr =3D + unsafe { ::core::ffi::CStr::from_bytes_with_nul_unchecked(b"hotplug-ha= ndler\0") }; +#[allow(unsafe_code)] +pub const TYPE_RESETTABLE_INTERFACE: &::core::ffi::CStr =3D + unsafe { ::core::ffi::CStr::from_bytes_with_nul_unchecked(b"resettable= \0") }; +#[allow(unsafe_code)] +pub const TYPE_DEVICE: &::core::ffi::CStr =3D + unsafe { ::core::ffi::CStr::from_bytes_with_nul_unchecked(b"device\0")= }; +#[allow(unsafe_code)] +pub const TYPE_BUS: &::core::ffi::CStr =3D + unsafe { ::core::ffi::CStr::from_bytes_with_nul_unchecked(b"bus\0") }; +#[allow(unsafe_code)] +pub const QDEV_HOTPLUG_HANDLER_PROPERTY: &::core::ffi::CStr =3D + unsafe { ::core::ffi::CStr::from_bytes_with_nul_unchecked(b"hotplug-ha= ndler\0") }; +#[allow(unsafe_code)] +pub const VADDR_PRId: &::core::ffi::CStr =3D + unsafe { ::core::ffi::CStr::from_bytes_with_nul_unchecked(b"ld\0") }; +#[allow(unsafe_code)] +pub const VADDR_PRIu: &::core::ffi::CStr =3D + unsafe { ::core::ffi::CStr::from_bytes_with_nul_unchecked(b"lu\0") }; +#[allow(unsafe_code)] +pub const VADDR_PRIo: &::core::ffi::CStr =3D + unsafe { ::core::ffi::CStr::from_bytes_with_nul_unchecked(b"lo\0") }; +#[allow(unsafe_code)] +pub const VADDR_PRIx: &::core::ffi::CStr =3D + unsafe { ::core::ffi::CStr::from_bytes_with_nul_unchecked(b"lx\0") }; +#[allow(unsafe_code)] +pub const VADDR_PRIX: &::core::ffi::CStr =3D + unsafe { ::core::ffi::CStr::from_bytes_with_nul_unchecked(b"lX\0") }; +pub const HWADDR_BITS: u32 =3D 64; +#[allow(unsafe_code)] +pub const HWADDR_FMT_plx: &::core::ffi::CStr =3D + unsafe { ::core::ffi::CStr::from_bytes_with_nul_unchecked(b"%016lx\0")= }; +#[allow(unsafe_code)] +pub const HWADDR_PRId: &::core::ffi::CStr =3D + unsafe { ::core::ffi::CStr::from_bytes_with_nul_unchecked(b"ld\0") }; +#[allow(unsafe_code)] +pub const HWADDR_PRIi: &::core::ffi::CStr =3D + unsafe { ::core::ffi::CStr::from_bytes_with_nul_unchecked(b"li\0") }; +#[allow(unsafe_code)] +pub const HWADDR_PRIo: &::core::ffi::CStr =3D + unsafe { ::core::ffi::CStr::from_bytes_with_nul_unchecked(b"lo\0") }; +#[allow(unsafe_code)] +pub const HWADDR_PRIu: &::core::ffi::CStr =3D + unsafe { ::core::ffi::CStr::from_bytes_with_nul_unchecked(b"lu\0") }; +#[allow(unsafe_code)] +pub const HWADDR_PRIx: &::core::ffi::CStr =3D + unsafe { ::core::ffi::CStr::from_bytes_with_nul_unchecked(b"lx\0") }; +#[allow(unsafe_code)] +pub const HWADDR_PRIX: &::core::ffi::CStr =3D + unsafe { ::core::ffi::CStr::from_bytes_with_nul_unchecked(b"lX\0") }; +pub const bfd_mach_m68000: u32 =3D 1; +pub const bfd_mach_m68008: u32 =3D 2; +pub const bfd_mach_m68010: u32 =3D 3; +pub const bfd_mach_m68020: u32 =3D 4; +pub const bfd_mach_m68030: u32 =3D 5; +pub const bfd_mach_m68040: u32 =3D 6; +pub const bfd_mach_m68060: u32 =3D 7; +pub const bfd_mach_cpu32: u32 =3D 8; +pub const bfd_mach_mcf5200: u32 =3D 9; +pub const bfd_mach_mcf5206e: u32 =3D 10; +pub const bfd_mach_mcf5307: u32 =3D 11; +pub const bfd_mach_mcf5407: u32 =3D 12; +pub const bfd_mach_mcf528x: u32 =3D 13; +pub const bfd_mach_mcfv4e: u32 =3D 14; +pub const bfd_mach_mcf521x: u32 =3D 15; +pub const bfd_mach_mcf5249: u32 =3D 16; +pub const bfd_mach_mcf547x: u32 =3D 17; +pub const bfd_mach_mcf548x: u32 =3D 18; +pub const bfd_mach_i960_core: u32 =3D 1; +pub const bfd_mach_i960_ka_sa: u32 =3D 2; +pub const bfd_mach_i960_kb_sb: u32 =3D 3; +pub const bfd_mach_i960_mc: u32 =3D 4; +pub const bfd_mach_i960_xa: u32 =3D 5; +pub const bfd_mach_i960_ca: u32 =3D 6; +pub const bfd_mach_i960_jx: u32 =3D 7; +pub const bfd_mach_i960_hx: u32 =3D 8; +pub const bfd_mach_sparc: u32 =3D 1; +pub const bfd_mach_sparc_sparclet: u32 =3D 2; +pub const bfd_mach_sparc_sparclite: u32 =3D 3; +pub const bfd_mach_sparc_v8plus: u32 =3D 4; +pub const bfd_mach_sparc_v8plusa: u32 =3D 5; +pub const bfd_mach_sparc_sparclite_le: u32 =3D 6; +pub const bfd_mach_sparc_v9: u32 =3D 7; +pub const bfd_mach_sparc_v9a: u32 =3D 8; +pub const bfd_mach_sparc_v8plusb: u32 =3D 9; +pub const bfd_mach_sparc_v9b: u32 =3D 10; +pub const bfd_mach_mips3000: u32 =3D 3000; +pub const bfd_mach_mips3900: u32 =3D 3900; +pub const bfd_mach_mips4000: u32 =3D 4000; +pub const bfd_mach_mips4010: u32 =3D 4010; +pub const bfd_mach_mips4100: u32 =3D 4100; +pub const bfd_mach_mips4300: u32 =3D 4300; +pub const bfd_mach_mips4400: u32 =3D 4400; +pub const bfd_mach_mips4600: u32 =3D 4600; +pub const bfd_mach_mips4650: u32 =3D 4650; +pub const bfd_mach_mips5000: u32 =3D 5000; +pub const bfd_mach_mips6000: u32 =3D 6000; +pub const bfd_mach_mips8000: u32 =3D 8000; +pub const bfd_mach_mips10000: u32 =3D 10000; +pub const bfd_mach_mips16: u32 =3D 16; +pub const bfd_mach_i386_i386: u32 =3D 0; +pub const bfd_mach_i386_i8086: u32 =3D 1; +pub const bfd_mach_i386_i386_intel_syntax: u32 =3D 2; +pub const bfd_mach_x86_64: u32 =3D 3; +pub const bfd_mach_x86_64_intel_syntax: u32 =3D 4; +pub const bfd_mach_h8300: u32 =3D 1; +pub const bfd_mach_h8300h: u32 =3D 2; +pub const bfd_mach_h8300s: u32 =3D 3; +pub const bfd_mach_ppc: u32 =3D 0; +pub const bfd_mach_ppc64: u32 =3D 1; +pub const bfd_mach_ppc_403: u32 =3D 403; +pub const bfd_mach_ppc_403gc: u32 =3D 4030; +pub const bfd_mach_ppc_e500: u32 =3D 500; +pub const bfd_mach_ppc_505: u32 =3D 505; +pub const bfd_mach_ppc_601: u32 =3D 601; +pub const bfd_mach_ppc_602: u32 =3D 602; +pub const bfd_mach_ppc_603: u32 =3D 603; +pub const bfd_mach_ppc_ec603e: u32 =3D 6031; +pub const bfd_mach_ppc_604: u32 =3D 604; +pub const bfd_mach_ppc_620: u32 =3D 620; +pub const bfd_mach_ppc_630: u32 =3D 630; +pub const bfd_mach_ppc_750: u32 =3D 750; +pub const bfd_mach_ppc_860: u32 =3D 860; +pub const bfd_mach_ppc_a35: u32 =3D 35; +pub const bfd_mach_ppc_rs64ii: u32 =3D 642; +pub const bfd_mach_ppc_rs64iii: u32 =3D 643; +pub const bfd_mach_ppc_7400: u32 =3D 7400; +pub const bfd_mach_hppa10: u32 =3D 10; +pub const bfd_mach_hppa11: u32 =3D 11; +pub const bfd_mach_hppa20: u32 =3D 20; +pub const bfd_mach_hppa20w: u32 =3D 25; +pub const bfd_mach_z8001: u32 =3D 1; +pub const bfd_mach_z8002: u32 =3D 2; +pub const bfd_mach_sh: u32 =3D 1; +pub const bfd_mach_sh2: u32 =3D 32; +pub const bfd_mach_sh_dsp: u32 =3D 45; +pub const bfd_mach_sh2a: u32 =3D 42; +pub const bfd_mach_sh2a_nofpu: u32 =3D 43; +pub const bfd_mach_sh2e: u32 =3D 46; +pub const bfd_mach_sh3: u32 =3D 48; +pub const bfd_mach_sh3_nommu: u32 =3D 49; +pub const bfd_mach_sh3_dsp: u32 =3D 61; +pub const bfd_mach_sh3e: u32 =3D 62; +pub const bfd_mach_sh4: u32 =3D 64; +pub const bfd_mach_sh4_nofpu: u32 =3D 65; +pub const bfd_mach_sh4_nommu_nofpu: u32 =3D 66; +pub const bfd_mach_sh4a: u32 =3D 74; +pub const bfd_mach_sh4a_nofpu: u32 =3D 75; +pub const bfd_mach_sh4al_dsp: u32 =3D 77; +pub const bfd_mach_sh5: u32 =3D 80; +pub const bfd_mach_alpha: u32 =3D 1; +pub const bfd_mach_alpha_ev4: u32 =3D 16; +pub const bfd_mach_alpha_ev5: u32 =3D 32; +pub const bfd_mach_alpha_ev6: u32 =3D 48; +pub const bfd_mach_arm_unknown: u32 =3D 0; +pub const bfd_mach_arm_2: u32 =3D 1; +pub const bfd_mach_arm_2a: u32 =3D 2; +pub const bfd_mach_arm_3: u32 =3D 3; +pub const bfd_mach_arm_3M: u32 =3D 4; +pub const bfd_mach_arm_4: u32 =3D 5; +pub const bfd_mach_arm_4T: u32 =3D 6; +pub const bfd_mach_arm_5: u32 =3D 7; +pub const bfd_mach_arm_5T: u32 =3D 8; +pub const bfd_mach_arm_5TE: u32 =3D 9; +pub const bfd_mach_arm_XScale: u32 =3D 10; +pub const bfd_mach_arm_ep9312: u32 =3D 11; +pub const bfd_mach_arm_iWMMXt: u32 =3D 12; +pub const bfd_mach_arm_iWMMXt2: u32 =3D 13; +pub const bfd_mach_v850: u32 =3D 0; +pub const bfd_mach_arc_base: u32 =3D 0; +pub const bfd_mach_m32r: u32 =3D 0; +pub const bfd_mach_avr1: u32 =3D 1; +pub const bfd_mach_avr2: u32 =3D 2; +pub const bfd_mach_avr25: u32 =3D 25; +pub const bfd_mach_avr3: u32 =3D 3; +pub const bfd_mach_avr31: u32 =3D 31; +pub const bfd_mach_avr35: u32 =3D 35; +pub const bfd_mach_avr4: u32 =3D 4; +pub const bfd_mach_avr5: u32 =3D 5; +pub const bfd_mach_avr51: u32 =3D 51; +pub const bfd_mach_avr6: u32 =3D 6; +pub const bfd_mach_avrtiny: u32 =3D 100; +pub const bfd_mach_avrxmega1: u32 =3D 101; +pub const bfd_mach_avrxmega2: u32 =3D 102; +pub const bfd_mach_avrxmega3: u32 =3D 103; +pub const bfd_mach_avrxmega4: u32 =3D 104; +pub const bfd_mach_avrxmega5: u32 =3D 105; +pub const bfd_mach_avrxmega6: u32 =3D 106; +pub const bfd_mach_avrxmega7: u32 =3D 107; +pub const bfd_mach_cris_v0_v10: u32 =3D 255; +pub const bfd_mach_cris_v32: u32 =3D 32; +pub const bfd_mach_cris_v10_v32: u32 =3D 1032; +pub const bfd_mach_ia64_elf64: u32 =3D 64; +pub const bfd_mach_ia64_elf32: u32 =3D 32; +pub const bfd_mach_rx: u32 =3D 117; +pub const bfd_mach_rx_v2: u32 =3D 118; +pub const bfd_mach_rx_v3: u32 =3D 119; +pub const bfd_mach_s390_31: u32 =3D 31; +pub const bfd_mach_s390_64: u32 =3D 64; +pub const INSN_HAS_RELOC: u32 =3D 2147483648; +pub const INSN_ARM_BE32: u32 =3D 65536; +pub const MEMTX_OK: u32 =3D 0; +pub const MEMTX_ERROR: u32 =3D 1; +pub const MEMTX_DECODE_ERROR: u32 =3D 2; +pub const MEMTX_ACCESS_ERROR: u32 =3D 4; +pub const MMU_ACCESS_COUNT: u32 =3D 3; +pub const EXEC_TLB_COMMON_H: u32 =3D 1; +pub const CPU_TLB_ENTRY_BITS: u32 =3D 5; +#[allow(unsafe_code)] +pub const TYPE_CPU: &::core::ffi::CStr =3D + unsafe { ::core::ffi::CStr::from_bytes_with_nul_unchecked(b"cpu\0") }; +pub const NB_MMU_MODES: u32 =3D 16; +pub const CPU_VTLB_SIZE: u32 =3D 8; +pub const CPU_UNSET_NUMA_NODE_ID: i32 =3D -1; +pub const SSTEP_ENABLE: u32 =3D 1; +pub const SSTEP_NOIRQ: u32 =3D 2; +pub const SSTEP_NOTIMER: u32 =3D 4; +pub const BP_MEM_READ: u32 =3D 1; +pub const BP_MEM_WRITE: u32 =3D 2; +pub const BP_MEM_ACCESS: u32 =3D 3; +pub const BP_STOP_BEFORE_ACCESS: u32 =3D 4; +pub const BP_GDB: u32 =3D 16; +pub const BP_CPU: u32 =3D 32; +pub const BP_ANY: u32 =3D 48; +pub const BP_HIT_SHIFT: u32 =3D 6; +pub const BP_WATCHPOINT_HIT_READ: u32 =3D 64; +pub const BP_WATCHPOINT_HIT_WRITE: u32 =3D 128; +pub const BP_WATCHPOINT_HIT: u32 =3D 192; +pub const UNASSIGNED_CPU_INDEX: i32 =3D -1; +pub const UNASSIGNED_CLUSTER_INDEX: i32 =3D -1; +pub const PAGE_READ: u32 =3D 1; +pub const PAGE_WRITE: u32 =3D 2; +pub const PAGE_EXEC: u32 =3D 4; +pub const PAGE_RWX: u32 =3D 7; +pub const PAGE_VALID: u32 =3D 8; +pub const PAGE_WRITE_ORG: u32 =3D 16; +pub const PAGE_WRITE_INV: u32 =3D 32; +pub const PAGE_RESET: u32 =3D 64; +pub const PAGE_ANON: u32 =3D 128; +pub const PAGE_TARGET_1: u32 =3D 512; +pub const PAGE_TARGET_2: u32 =3D 1024; +pub const PAGE_PASSTHROUGH: u32 =3D 2048; +pub const EXCP_INTERRUPT: u32 =3D 65536; +pub const EXCP_HLT: u32 =3D 65537; +pub const EXCP_DEBUG: u32 =3D 65538; +pub const EXCP_HALTED: u32 =3D 65539; +pub const EXCP_YIELD: u32 =3D 65540; +pub const EXCP_ATOMIC: u32 =3D 65541; +#[allow(unsafe_code)] +pub const RAM_ADDR_FMT: &::core::ffi::CStr =3D + unsafe { ::core::ffi::CStr::from_bytes_with_nul_unchecked(b"%lx\0") }; +pub const DIRTY_MEMORY_VGA: u32 =3D 0; +pub const DIRTY_MEMORY_CODE: u32 =3D 1; +pub const DIRTY_MEMORY_MIGRATION: u32 =3D 2; +pub const DIRTY_MEMORY_NUM: u32 =3D 3; +pub const MAX_PHYS_ADDR_SPACE_BITS: u32 =3D 62; +#[allow(unsafe_code)] +pub const TYPE_MEMORY_REGION: &::core::ffi::CStr =3D + unsafe { ::core::ffi::CStr::from_bytes_with_nul_unchecked(b"memory-reg= ion\0") }; +#[allow(unsafe_code)] +pub const TYPE_IOMMU_MEMORY_REGION: &::core::ffi::CStr =3D + unsafe { ::core::ffi::CStr::from_bytes_with_nul_unchecked(b"iommu-memo= ry-region\0") }; +#[allow(unsafe_code)] +pub const TYPE_RAM_DISCARD_MANAGER: &::core::ffi::CStr =3D + unsafe { ::core::ffi::CStr::from_bytes_with_nul_unchecked(b"ram-discar= d-manager\0") }; +pub const GLOBAL_DIRTY_MIGRATION: u32 =3D 1; +pub const GLOBAL_DIRTY_DIRTY_RATE: u32 =3D 2; +pub const GLOBAL_DIRTY_LIMIT: u32 =3D 4; +pub const GLOBAL_DIRTY_MASK: u32 =3D 7; +pub const RAM_PREALLOC: u32 =3D 1; +pub const RAM_SHARED: u32 =3D 2; +pub const RAM_RESIZEABLE: u32 =3D 4; +pub const RAM_UF_ZEROPAGE: u32 =3D 8; +pub const RAM_MIGRATABLE: u32 =3D 16; +pub const RAM_PMEM: u32 =3D 32; +pub const RAM_UF_WRITEPROTECT: u32 =3D 64; +pub const RAM_NORESERVE: u32 =3D 128; +pub const RAM_PROTECTED: u32 =3D 256; +pub const RAM_NAMED_FILE: u32 =3D 512; +pub const RAM_READONLY: u32 =3D 1024; +pub const RAM_READONLY_FD: u32 =3D 2048; +pub const RAM_GUEST_MEMFD: u32 =3D 4096; +pub const MEMORY_LISTENER_PRIORITY_MIN: u32 =3D 0; +pub const MEMORY_LISTENER_PRIORITY_ACCEL: u32 =3D 10; +pub const MEMORY_LISTENER_PRIORITY_DEV_BACKEND: u32 =3D 10; +pub const QDEV_MAX_MMIO: u32 =3D 32; +pub const QDEV_MAX_PIO: u32 =3D 32; +#[allow(unsafe_code)] +pub const TYPE_SYSTEM_BUS: &::core::ffi::CStr =3D + unsafe { ::core::ffi::CStr::from_bytes_with_nul_unchecked(b"System\0")= }; +#[allow(unsafe_code)] +pub const TYPE_SYS_BUS_DEVICE: &::core::ffi::CStr =3D + unsafe { ::core::ffi::CStr::from_bytes_with_nul_unchecked(b"sys-bus-de= vice\0") }; +#[allow(unsafe_code)] +pub const SYSBUS_DEVICE_GPIO_IRQ: &::core::ffi::CStr =3D + unsafe { ::core::ffi::CStr::from_bytes_with_nul_unchecked(b"sysbus-irq= \0") }; +pub const IAC_EOR: u32 =3D 239; +pub const IAC_SE: u32 =3D 240; +pub const IAC_NOP: u32 =3D 241; +pub const IAC_BREAK: u32 =3D 243; +pub const IAC_IP: u32 =3D 244; +pub const IAC_SB: u32 =3D 250; +pub const IAC: u32 =3D 255; +pub const CHR_READ_BUF_LEN: u32 =3D 4096; +#[allow(unsafe_code)] +pub const TYPE_CHARDEV: &::core::ffi::CStr =3D + unsafe { ::core::ffi::CStr::from_bytes_with_nul_unchecked(b"chardev\0"= ) }; +#[allow(unsafe_code)] +pub const TYPE_CHARDEV_NULL: &::core::ffi::CStr =3D + unsafe { ::core::ffi::CStr::from_bytes_with_nul_unchecked(b"chardev-nu= ll\0") }; +#[allow(unsafe_code)] +pub const TYPE_CHARDEV_MUX: &::core::ffi::CStr =3D + unsafe { ::core::ffi::CStr::from_bytes_with_nul_unchecked(b"chardev-mu= x\0") }; +#[allow(unsafe_code)] +pub const TYPE_CHARDEV_RINGBUF: &::core::ffi::CStr =3D + unsafe { ::core::ffi::CStr::from_bytes_with_nul_unchecked(b"chardev-ri= ngbuf\0") }; +#[allow(unsafe_code)] +pub const TYPE_CHARDEV_PTY: &::core::ffi::CStr =3D + unsafe { ::core::ffi::CStr::from_bytes_with_nul_unchecked(b"chardev-pt= y\0") }; +#[allow(unsafe_code)] +pub const TYPE_CHARDEV_CONSOLE: &::core::ffi::CStr =3D + unsafe { ::core::ffi::CStr::from_bytes_with_nul_unchecked(b"chardev-co= nsole\0") }; +#[allow(unsafe_code)] +pub const TYPE_CHARDEV_STDIO: &::core::ffi::CStr =3D + unsafe { ::core::ffi::CStr::from_bytes_with_nul_unchecked(b"chardev-st= dio\0") }; +#[allow(unsafe_code)] +pub const TYPE_CHARDEV_PIPE: &::core::ffi::CStr =3D + unsafe { ::core::ffi::CStr::from_bytes_with_nul_unchecked(b"chardev-pi= pe\0") }; +#[allow(unsafe_code)] +pub const TYPE_CHARDEV_MEMORY: &::core::ffi::CStr =3D + unsafe { ::core::ffi::CStr::from_bytes_with_nul_unchecked(b"chardev-me= mory\0") }; +#[allow(unsafe_code)] +pub const TYPE_CHARDEV_PARALLEL: &::core::ffi::CStr =3D + unsafe { ::core::ffi::CStr::from_bytes_with_nul_unchecked(b"chardev-pa= rallel\0") }; +#[allow(unsafe_code)] +pub const TYPE_CHARDEV_FILE: &::core::ffi::CStr =3D + unsafe { ::core::ffi::CStr::from_bytes_with_nul_unchecked(b"chardev-fi= le\0") }; +#[allow(unsafe_code)] +pub const TYPE_CHARDEV_SERIAL: &::core::ffi::CStr =3D + unsafe { ::core::ffi::CStr::from_bytes_with_nul_unchecked(b"chardev-se= rial\0") }; +#[allow(unsafe_code)] +pub const TYPE_CHARDEV_SOCKET: &::core::ffi::CStr =3D + unsafe { ::core::ffi::CStr::from_bytes_with_nul_unchecked(b"chardev-so= cket\0") }; +#[allow(unsafe_code)] +pub const TYPE_CHARDEV_UDP: &::core::ffi::CStr =3D + unsafe { ::core::ffi::CStr::from_bytes_with_nul_unchecked(b"chardev-ud= p\0") }; +#[allow(unsafe_code)] +pub const TYPE_EVENT_LOOP_BASE: &::core::ffi::CStr =3D + unsafe { ::core::ffi::CStr::from_bytes_with_nul_unchecked(b"event-loop= -base\0") }; +pub const SIG_IPI: u32 =3D 10; +#[allow(unsafe_code)] +pub const TYPE_MAIN_LOOP: &::core::ffi::CStr =3D + unsafe { ::core::ffi::CStr::from_bytes_with_nul_unchecked(b"main-loop\= 0") }; +#[allow(unsafe_code)] +pub const TYPE_CLOCK: &::core::ffi::CStr =3D + unsafe { ::core::ffi::CStr::from_bytes_with_nul_unchecked(b"clock\0") = }; +pub const CLOCK_PERIOD_1SEC: u64 =3D 4294967296000000000; +#[allow(unsafe_code)] +pub const TYPE_IRQ: &::core::ffi::CStr =3D + unsafe { ::core::ffi::CStr::from_bytes_with_nul_unchecked(b"irq\0") }; +#[allow(unsafe_code)] +pub const TYPE_VMSTATE_IF: &::core::ffi::CStr =3D + unsafe { ::core::ffi::CStr::from_bytes_with_nul_unchecked(b"vmstate-if= \0") }; +pub const VMS_NULLPTR_MARKER: u32 =3D 48; +pub const VMSTATE_INSTANCE_ID_ANY: i32 =3D -1; +pub const CHR_IOCTL_SERIAL_SET_PARAMS: u32 =3D 1; +pub const CHR_IOCTL_SERIAL_SET_BREAK: u32 =3D 2; +pub const CHR_IOCTL_SERIAL_SET_TIOCM: u32 =3D 13; +pub const CHR_IOCTL_SERIAL_GET_TIOCM: u32 =3D 14; +pub const CHR_TIOCM_CTS: u32 =3D 32; +pub const CHR_TIOCM_CAR: u32 =3D 64; +pub const CHR_TIOCM_DSR: u32 =3D 256; +pub const CHR_TIOCM_RI: u32 =3D 128; +pub const CHR_TIOCM_DTR: u32 =3D 2; +pub const CHR_TIOCM_RTS: u32 =3D 4; +pub type va_list =3D __builtin_va_list; +pub type __gnuc_va_list =3D __builtin_va_list; +pub type wchar_t =3D core::ffi::c_int; +pub type __u_char =3D core::ffi::c_uchar; +pub type __u_short =3D core::ffi::c_ushort; +pub type __u_int =3D core::ffi::c_uint; +pub type __u_long =3D core::ffi::c_ulong; +pub type __int8_t =3D core::ffi::c_schar; +pub type __uint8_t =3D core::ffi::c_uchar; +pub type __int16_t =3D core::ffi::c_short; +pub type __uint16_t =3D core::ffi::c_ushort; +pub type __int32_t =3D core::ffi::c_int; +pub type __uint32_t =3D core::ffi::c_uint; +pub type __int64_t =3D core::ffi::c_long; +pub type __uint64_t =3D core::ffi::c_ulong; +pub type __int_least8_t =3D __int8_t; +pub type __uint_least8_t =3D __uint8_t; +pub type __int_least16_t =3D __int16_t; +pub type __uint_least16_t =3D __uint16_t; +pub type __int_least32_t =3D __int32_t; +pub type __uint_least32_t =3D __uint32_t; +pub type __int_least64_t =3D __int64_t; +pub type __uint_least64_t =3D __uint64_t; +pub type __quad_t =3D core::ffi::c_long; +pub type __u_quad_t =3D core::ffi::c_ulong; +pub type __intmax_t =3D core::ffi::c_long; +pub type __uintmax_t =3D core::ffi::c_ulong; +pub type __dev_t =3D core::ffi::c_ulong; +pub type __uid_t =3D core::ffi::c_uint; +pub type __gid_t =3D core::ffi::c_uint; +pub type __ino_t =3D core::ffi::c_ulong; +pub type __ino64_t =3D core::ffi::c_ulong; +pub type __mode_t =3D core::ffi::c_uint; +pub type __nlink_t =3D core::ffi::c_ulong; +pub type __off_t =3D core::ffi::c_long; +pub type __off64_t =3D core::ffi::c_long; +pub type __pid_t =3D core::ffi::c_int; +#[repr(C)] +#[derive(Debug, Default, Copy, Clone)] +pub struct __fsid_t { + pub __val: [core::ffi::c_int; 2usize], +} +#[test] +fn bindgen_test_layout___fsid_t() { + const UNINIT: ::core::mem::MaybeUninit<__fsid_t> =3D ::core::mem::Mayb= eUninit::uninit(); + let ptr =3D UNINIT.as_ptr(); + assert_eq!( + ::core::mem::size_of::<__fsid_t>(), + 8usize, + concat!("Size of: ", stringify!(__fsid_t)) + ); + assert_eq!( + ::core::mem::align_of::<__fsid_t>(), + 4usize, + concat!("Alignment of ", stringify!(__fsid_t)) + ); + assert_eq!( + unsafe { ::core::ptr::addr_of!((*ptr).__val) as usize - ptr as usi= ze }, + 0usize, + concat!( + "Offset of field: ", + stringify!(__fsid_t), + "::", + stringify!(__val) + ) + ); +} +pub type __clock_t =3D core::ffi::c_long; +pub type __rlim_t =3D core::ffi::c_ulong; +pub type __rlim64_t =3D core::ffi::c_ulong; +pub type __id_t =3D core::ffi::c_uint; +pub type __time_t =3D core::ffi::c_long; +pub type __useconds_t =3D core::ffi::c_uint; +pub type __suseconds_t =3D core::ffi::c_long; +pub type __suseconds64_t =3D core::ffi::c_long; +pub type __daddr_t =3D core::ffi::c_int; +pub type __key_t =3D core::ffi::c_int; +pub type __clockid_t =3D core::ffi::c_int; +pub type __timer_t =3D *mut core::ffi::c_void; +pub type __blksize_t =3D core::ffi::c_long; +pub type __blkcnt_t =3D core::ffi::c_long; +pub type __blkcnt64_t =3D core::ffi::c_long; +pub type __fsblkcnt_t =3D core::ffi::c_ulong; +pub type __fsblkcnt64_t =3D core::ffi::c_ulong; +pub type __fsfilcnt_t =3D core::ffi::c_ulong; +pub type __fsfilcnt64_t =3D core::ffi::c_ulong; +pub type __fsword_t =3D core::ffi::c_long; +pub type __ssize_t =3D core::ffi::c_long; +pub type __syscall_slong_t =3D core::ffi::c_long; +pub type __syscall_ulong_t =3D core::ffi::c_ulong; +pub type __loff_t =3D __off64_t; +pub type __caddr_t =3D *mut core::ffi::c_char; +pub type __intptr_t =3D core::ffi::c_long; +pub type __socklen_t =3D core::ffi::c_uint; +pub type __sig_atomic_t =3D core::ffi::c_int; +pub type u_char =3D __u_char; +pub type u_short =3D __u_short; +pub type u_int =3D __u_int; +pub type u_long =3D __u_long; +pub type quad_t =3D __quad_t; +pub type u_quad_t =3D __u_quad_t; +pub type fsid_t =3D __fsid_t; +pub type loff_t =3D __loff_t; +pub type ino_t =3D __ino64_t; +pub type ino64_t =3D __ino64_t; +pub type dev_t =3D __dev_t; +pub type gid_t =3D __gid_t; +pub type mode_t =3D __mode_t; +pub type nlink_t =3D __nlink_t; +pub type uid_t =3D __uid_t; +pub type off_t =3D __off64_t; +pub type off64_t =3D __off64_t; +pub type pid_t =3D __pid_t; +pub type id_t =3D __id_t; +pub type daddr_t =3D __daddr_t; +pub type caddr_t =3D __caddr_t; +pub type key_t =3D __key_t; +pub type clock_t =3D __clock_t; +pub type clockid_t =3D __clockid_t; +pub type time_t =3D __time_t; +pub type timer_t =3D __timer_t; +pub type useconds_t =3D __useconds_t; +pub type suseconds_t =3D __suseconds_t; +pub type ulong =3D core::ffi::c_ulong; +pub type ushort =3D core::ffi::c_ushort; +pub type uint =3D core::ffi::c_uint; +pub type u_int8_t =3D __uint8_t; +pub type u_int16_t =3D __uint16_t; +pub type u_int32_t =3D __uint32_t; +pub type u_int64_t =3D __uint64_t; +pub type register_t =3D core::ffi::c_long; +#[repr(C)] +#[derive(Debug, Default, Copy, Clone)] +pub struct __sigset_t { + pub __val: [core::ffi::c_ulong; 16usize], +} +#[test] +fn bindgen_test_layout___sigset_t() { + const UNINIT: ::core::mem::MaybeUninit<__sigset_t> =3D ::core::mem::Ma= ybeUninit::uninit(); + let ptr =3D UNINIT.as_ptr(); + assert_eq!( + ::core::mem::size_of::<__sigset_t>(), + 128usize, + concat!("Size of: ", stringify!(__sigset_t)) + ); + assert_eq!( + ::core::mem::align_of::<__sigset_t>(), + 8usize, + concat!("Alignment of ", stringify!(__sigset_t)) + ); + assert_eq!( + unsafe { ::core::ptr::addr_of!((*ptr).__val) as usize - ptr as usi= ze }, + 0usize, + concat!( + "Offset of field: ", + stringify!(__sigset_t), + "::", + stringify!(__val) + ) + ); +} +pub type sigset_t =3D __sigset_t; +#[repr(C)] +#[derive(Debug, Default, Copy, Clone)] +pub struct timeval { + pub tv_sec: __time_t, + pub tv_usec: __suseconds_t, +} +#[test] +fn bindgen_test_layout_timeval() { + const UNINIT: ::core::mem::MaybeUninit =3D ::core::mem::Maybe= Uninit::uninit(); + let ptr =3D UNINIT.as_ptr(); + assert_eq!( + ::core::mem::size_of::(), + 16usize, + concat!("Size of: ", stringify!(timeval)) + ); + assert_eq!( + ::core::mem::align_of::(), + 8usize, + concat!("Alignment of ", stringify!(timeval)) + ); + assert_eq!( + unsafe { ::core::ptr::addr_of!((*ptr).tv_sec) as usize - ptr as us= ize }, + 0usize, + concat!( + "Offset of field: ", + stringify!(timeval), + "::", + stringify!(tv_sec) + ) + ); + assert_eq!( + unsafe { ::core::ptr::addr_of!((*ptr).tv_usec) as usize - ptr as u= size }, + 8usize, + concat!( + "Offset of field: ", + stringify!(timeval), + "::", + stringify!(tv_usec) + ) + ); +} +#[repr(C)] +#[derive(Debug, Default, Copy, Clone)] +pub struct timespec { + pub tv_sec: __time_t, + pub tv_nsec: __syscall_slong_t, +} +#[test] +fn bindgen_test_layout_timespec() { + const UNINIT: ::core::mem::MaybeUninit =3D ::core::mem::Mayb= eUninit::uninit(); + let ptr =3D UNINIT.as_ptr(); + assert_eq!( + ::core::mem::size_of::(), + 16usize, + concat!("Size of: ", stringify!(timespec)) + ); + assert_eq!( + ::core::mem::align_of::(), + 8usize, + concat!("Alignment of ", stringify!(timespec)) + ); + assert_eq!( + unsafe { ::core::ptr::addr_of!((*ptr).tv_sec) as usize - ptr as us= ize }, + 0usize, + concat!( + "Offset of field: ", + stringify!(timespec), + "::", + stringify!(tv_sec) + ) + ); + assert_eq!( + unsafe { ::core::ptr::addr_of!((*ptr).tv_nsec) as usize - ptr as u= size }, + 8usize, + concat!( + "Offset of field: ", + stringify!(timespec), + "::", + stringify!(tv_nsec) + ) + ); +} +pub type __fd_mask =3D core::ffi::c_long; +#[repr(C)] +#[derive(Debug, Default, Copy, Clone)] +pub struct fd_set { + pub fds_bits: [__fd_mask; 16usize], +} +#[test] +fn bindgen_test_layout_fd_set() { + const UNINIT: ::core::mem::MaybeUninit =3D ::core::mem::MaybeU= ninit::uninit(); + let ptr =3D UNINIT.as_ptr(); + assert_eq!( + ::core::mem::size_of::(), + 128usize, + concat!("Size of: ", stringify!(fd_set)) + ); + assert_eq!( + ::core::mem::align_of::(), + 8usize, + concat!("Alignment of ", stringify!(fd_set)) + ); + assert_eq!( + unsafe { ::core::ptr::addr_of!((*ptr).fds_bits) as usize - ptr as = usize }, + 0usize, + concat!( + "Offset of field: ", + stringify!(fd_set), + "::", + stringify!(fds_bits) + ) + ); +} +pub type fd_mask =3D __fd_mask; +pub type blksize_t =3D __blksize_t; +pub type blkcnt_t =3D __blkcnt64_t; +pub type fsblkcnt_t =3D __fsblkcnt64_t; +pub type fsfilcnt_t =3D __fsfilcnt64_t; +pub type blkcnt64_t =3D __blkcnt64_t; +pub type fsblkcnt64_t =3D __fsblkcnt64_t; +pub type fsfilcnt64_t =3D __fsfilcnt64_t; +#[repr(C)] +#[derive(Copy, Clone)] +pub union __atomic_wide_counter { + pub __value64: core::ffi::c_ulonglong, + pub __value32: __atomic_wide_counter__bindgen_ty_1, +} +#[repr(C)] +#[derive(Debug, Default, Copy, Clone)] +pub struct __atomic_wide_counter__bindgen_ty_1 { + pub __low: core::ffi::c_uint, + pub __high: core::ffi::c_uint, +} +#[test] +fn bindgen_test_layout___atomic_wide_counter__bindgen_ty_1() { + const UNINIT: ::core::mem::MaybeUninit<__atomic_wide_counter__bindgen_= ty_1> =3D + ::core::mem::MaybeUninit::uninit(); + let ptr =3D UNINIT.as_ptr(); + assert_eq!( + ::core::mem::size_of::<__atomic_wide_counter__bindgen_ty_1>(), + 8usize, + concat!("Size of: ", stringify!(__atomic_wide_counter__bindgen_ty_= 1)) + ); + assert_eq!( + ::core::mem::align_of::<__atomic_wide_counter__bindgen_ty_1>(), + 4usize, + concat!( + "Alignment of ", + stringify!(__atomic_wide_counter__bindgen_ty_1) + ) + ); + assert_eq!( + unsafe { ::core::ptr::addr_of!((*ptr).__low) as usize - ptr as usi= ze }, + 0usize, + concat!( + "Offset of field: ", + stringify!(__atomic_wide_counter__bindgen_ty_1), + "::", + stringify!(__low) + ) + ); + assert_eq!( + unsafe { ::core::ptr::addr_of!((*ptr).__high) as usize - ptr as us= ize }, + 4usize, + concat!( + "Offset of field: ", + stringify!(__atomic_wide_counter__bindgen_ty_1), + "::", + stringify!(__high) + ) + ); +} +#[test] +fn bindgen_test_layout___atomic_wide_counter() { + const UNINIT: ::core::mem::MaybeUninit<__atomic_wide_counter> =3D + ::core::mem::MaybeUninit::uninit(); + let ptr =3D UNINIT.as_ptr(); + assert_eq!( + ::core::mem::size_of::<__atomic_wide_counter>(), + 8usize, + concat!("Size of: ", stringify!(__atomic_wide_counter)) + ); + assert_eq!( + ::core::mem::align_of::<__atomic_wide_counter>(), + 8usize, + concat!("Alignment of ", stringify!(__atomic_wide_counter)) + ); + assert_eq!( + unsafe { ::core::ptr::addr_of!((*ptr).__value64) as usize - ptr as= usize }, + 0usize, + concat!( + "Offset of field: ", + stringify!(__atomic_wide_counter), + "::", + stringify!(__value64) + ) + ); + assert_eq!( + unsafe { ::core::ptr::addr_of!((*ptr).__value32) as usize - ptr as= usize }, + 0usize, + concat!( + "Offset of field: ", + stringify!(__atomic_wide_counter), + "::", + stringify!(__value32) + ) + ); +} +impl Default for __atomic_wide_counter { + fn default() -> Self { + let mut s =3D ::core::mem::MaybeUninit::::uninit(); + unsafe { + ::core::ptr::write_bytes(s.as_mut_ptr(), 0, 1); + s.assume_init() + } + } +} +impl ::core::fmt::Debug for __atomic_wide_counter { + fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Resu= lt { + write!(f, "__atomic_wide_counter {{ union }}") + } +} +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct __pthread_internal_list { + pub __prev: *mut __pthread_internal_list, + pub __next: *mut __pthread_internal_list, +} +#[test] +fn bindgen_test_layout___pthread_internal_list() { + const UNINIT: ::core::mem::MaybeUninit<__pthread_internal_list> =3D + ::core::mem::MaybeUninit::uninit(); + let ptr =3D UNINIT.as_ptr(); + assert_eq!( + ::core::mem::size_of::<__pthread_internal_list>(), + 16usize, + concat!("Size of: ", stringify!(__pthread_internal_list)) + ); + assert_eq!( + ::core::mem::align_of::<__pthread_internal_list>(), + 8usize, + concat!("Alignment of ", stringify!(__pthread_internal_list)) + ); + assert_eq!( + unsafe { ::core::ptr::addr_of!((*ptr).__prev) as usize - ptr as us= ize }, + 0usize, + concat!( + "Offset of field: ", + stringify!(__pthread_internal_list), + "::", + stringify!(__prev) + ) + ); + assert_eq!( + unsafe { ::core::ptr::addr_of!((*ptr).__next) as usize - ptr as us= ize }, + 8usize, + concat!( + "Offset of field: ", + stringify!(__pthread_internal_list), + "::", + stringify!(__next) + ) + ); +} +impl Default for __pthread_internal_list { + fn default() -> Self { + let mut s =3D ::core::mem::MaybeUninit::::uninit(); + unsafe { + ::core::ptr::write_bytes(s.as_mut_ptr(), 0, 1); + s.assume_init() + } + } +} +pub type __pthread_list_t =3D __pthread_internal_list; +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct __pthread_internal_slist { + pub __next: *mut __pthread_internal_slist, +} +#[test] +fn bindgen_test_layout___pthread_internal_slist() { + const UNINIT: ::core::mem::MaybeUninit<__pthread_internal_slist> =3D + ::core::mem::MaybeUninit::uninit(); + let ptr =3D UNINIT.as_ptr(); + assert_eq!( + ::core::mem::size_of::<__pthread_internal_slist>(), + 8usize, + concat!("Size of: ", stringify!(__pthread_internal_slist)) + ); + assert_eq!( + ::core::mem::align_of::<__pthread_internal_slist>(), + 8usize, + concat!("Alignment of ", stringify!(__pthread_internal_slist)) + ); + assert_eq!( + unsafe { ::core::ptr::addr_of!((*ptr).__next) as usize - ptr as us= ize }, + 0usize, + concat!( + "Offset of field: ", + stringify!(__pthread_internal_slist), + "::", + stringify!(__next) + ) + ); +} +impl Default for __pthread_internal_slist { + fn default() -> Self { + let mut s =3D ::core::mem::MaybeUninit::::uninit(); + unsafe { + ::core::ptr::write_bytes(s.as_mut_ptr(), 0, 1); + s.assume_init() + } + } +} +pub type __pthread_slist_t =3D __pthread_internal_slist; +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct __pthread_mutex_s { + pub __lock: core::ffi::c_int, + pub __count: core::ffi::c_uint, + pub __owner: core::ffi::c_int, + pub __nusers: core::ffi::c_uint, + pub __kind: core::ffi::c_int, + pub __spins: core::ffi::c_short, + pub __elision: core::ffi::c_short, + pub __list: __pthread_list_t, +} +#[test] +fn bindgen_test_layout___pthread_mutex_s() { + const UNINIT: ::core::mem::MaybeUninit<__pthread_mutex_s> =3D ::core::= mem::MaybeUninit::uninit(); + let ptr =3D UNINIT.as_ptr(); + assert_eq!( + ::core::mem::size_of::<__pthread_mutex_s>(), + 40usize, + concat!("Size of: ", stringify!(__pthread_mutex_s)) + ); + assert_eq!( + ::core::mem::align_of::<__pthread_mutex_s>(), + 8usize, + concat!("Alignment of ", stringify!(__pthread_mutex_s)) + ); + assert_eq!( + unsafe { ::core::ptr::addr_of!((*ptr).__lock) as usize - ptr as us= ize }, + 0usize, + concat!( + "Offset of field: ", + stringify!(__pthread_mutex_s), + "::", + stringify!(__lock) + ) + ); + assert_eq!( + unsafe { ::core::ptr::addr_of!((*ptr).__count) as usize - ptr as u= size }, + 4usize, + concat!( + "Offset of field: ", + stringify!(__pthread_mutex_s), + "::", + stringify!(__count) + ) + ); + assert_eq!( + unsafe { ::core::ptr::addr_of!((*ptr).__owner) as usize - ptr as u= size }, + 8usize, + concat!( + "Offset of field: ", + stringify!(__pthread_mutex_s), + "::", + stringify!(__owner) + ) + ); + assert_eq!( + unsafe { ::core::ptr::addr_of!((*ptr).__nusers) as usize - ptr as = usize }, + 12usize, + concat!( + "Offset of field: ", + stringify!(__pthread_mutex_s), + "::", + stringify!(__nusers) + ) + ); + assert_eq!( + unsafe { ::core::ptr::addr_of!((*ptr).__kind) as usize - ptr as us= ize }, + 16usize, + concat!( + "Offset of field: ", + stringify!(__pthread_mutex_s), + "::", + stringify!(__kind) + ) + ); + assert_eq!( + unsafe { ::core::ptr::addr_of!((*ptr).__spins) as usize - ptr as u= size }, + 20usize, + concat!( + "Offset of field: ", + stringify!(__pthread_mutex_s), + "::", + stringify!(__spins) + ) + ); + assert_eq!( + unsafe { ::core::ptr::addr_of!((*ptr).__elision) as usize - ptr as= usize }, + 22usize, + concat!( + "Offset of field: ", + stringify!(__pthread_mutex_s), + "::", + stringify!(__elision) + ) + ); + assert_eq!( + unsafe { ::core::ptr::addr_of!((*ptr).__list) as usize - ptr as us= ize }, + 24usize, + concat!( + "Offset of field: ", + stringify!(__pthread_mutex_s), + "::", + stringify!(__list) + ) + ); +} +impl Default for __pthread_mutex_s { + fn default() -> Self { + let mut s =3D ::core::mem::MaybeUninit::::uninit(); + unsafe { + ::core::ptr::write_bytes(s.as_mut_ptr(), 0, 1); + s.assume_init() + } + } +} +#[repr(C)] +#[derive(Debug, Default, Copy, Clone)] +pub struct __pthread_rwlock_arch_t { + pub __readers: core::ffi::c_uint, + pub __writers: core::ffi::c_uint, + pub __wrphase_futex: core::ffi::c_uint, + pub __writers_futex: core::ffi::c_uint, + pub __pad3: core::ffi::c_uint, + pub __pad4: core::ffi::c_uint, + pub __cur_writer: core::ffi::c_int, + pub __shared: core::ffi::c_int, + pub __rwelision: core::ffi::c_schar, + pub __pad1: [core::ffi::c_uchar; 7usize], + pub __pad2: core::ffi::c_ulong, + pub __flags: core::ffi::c_uint, +} +#[test] +fn bindgen_test_layout___pthread_rwlock_arch_t() { + const UNINIT: ::core::mem::MaybeUninit<__pthread_rwlock_arch_t> =3D + ::core::mem::MaybeUninit::uninit(); + let ptr =3D UNINIT.as_ptr(); + assert_eq!( + ::core::mem::size_of::<__pthread_rwlock_arch_t>(), + 56usize, + concat!("Size of: ", stringify!(__pthread_rwlock_arch_t)) + ); + assert_eq!( + ::core::mem::align_of::<__pthread_rwlock_arch_t>(), + 8usize, + concat!("Alignment of ", stringify!(__pthread_rwlock_arch_t)) + ); + assert_eq!( + unsafe { ::core::ptr::addr_of!((*ptr).__readers) as usize - ptr as= usize }, + 0usize, + concat!( + "Offset of field: ", + stringify!(__pthread_rwlock_arch_t), + "::", + stringify!(__readers) + ) + ); + assert_eq!( + unsafe { ::core::ptr::addr_of!((*ptr).__writers) as usize - ptr as= usize }, + 4usize, + concat!( + "Offset of field: ", + stringify!(__pthread_rwlock_arch_t), + "::", + stringify!(__writers) + ) + ); + assert_eq!( + unsafe { ::core::ptr::addr_of!((*ptr).__wrphase_futex) as usize - = ptr as usize }, + 8usize, + concat!( + "Offset of field: ", + stringify!(__pthread_rwlock_arch_t), + "::", + stringify!(__wrphase_futex) + ) + ); + assert_eq!( + unsafe { ::core::ptr::addr_of!((*ptr).__writers_futex) as usize - = ptr as usize }, + 12usize, + concat!( + "Offset of field: ", + stringify!(__pthread_rwlock_arch_t), + "::", + stringify!(__writers_futex) + ) + ); + assert_eq!( + unsafe { ::core::ptr::addr_of!((*ptr).__pad3) as usize - ptr as us= ize }, + 16usize, + concat!( + "Offset of field: ", + stringify!(__pthread_rwlock_arch_t), + "::", + stringify!(__pad3) + ) + ); + assert_eq!( + unsafe { ::core::ptr::addr_of!((*ptr).__pad4) as usize - ptr as us= ize }, + 20usize, + concat!( + "Offset of field: ", + stringify!(__pthread_rwlock_arch_t), + "::", + stringify!(__pad4) + ) + ); + assert_eq!( + unsafe { ::core::ptr::addr_of!((*ptr).__cur_writer) as usize - ptr= as usize }, + 24usize, + concat!( + "Offset of field: ", + stringify!(__pthread_rwlock_arch_t), + "::", + stringify!(__cur_writer) + ) + ); + assert_eq!( + unsafe { ::core::ptr::addr_of!((*ptr).__shared) as usize - ptr as = usize }, + 28usize, + concat!( + "Offset of field: ", + stringify!(__pthread_rwlock_arch_t), + "::", + stringify!(__shared) + ) + ); + assert_eq!( + unsafe { ::core::ptr::addr_of!((*ptr).__rwelision) as usize - ptr = as usize }, + 32usize, + concat!( + "Offset of field: ", + stringify!(__pthread_rwlock_arch_t), + "::", + stringify!(__rwelision) + ) + ); + assert_eq!( + unsafe { ::core::ptr::addr_of!((*ptr).__pad1) as usize - ptr as us= ize }, + 33usize, + concat!( + "Offset of field: ", + stringify!(__pthread_rwlock_arch_t), + "::", + stringify!(__pad1) + ) + ); + assert_eq!( + unsafe { ::core::ptr::addr_of!((*ptr).__pad2) as usize - ptr as us= ize }, + 40usize, + concat!( + "Offset of field: ", + stringify!(__pthread_rwlock_arch_t), + "::", + stringify!(__pad2) + ) + ); + assert_eq!( + unsafe { ::core::ptr::addr_of!((*ptr).__flags) as usize - ptr as u= size }, + 48usize, + concat!( + "Offset of field: ", + stringify!(__pthread_rwlock_arch_t), + "::", + stringify!(__flags) + ) + ); +} +#[repr(C)] +#[derive(Copy, Clone)] +pub struct __pthread_cond_s { + pub __wseq: __atomic_wide_counter, + pub __g1_start: __atomic_wide_counter, + pub __g_refs: [core::ffi::c_uint; 2usize], + pub __g_size: [core::ffi::c_uint; 2usize], + pub __g1_orig_size: core::ffi::c_uint, + pub __wrefs: core::ffi::c_uint, + pub __g_signals: [core::ffi::c_uint; 2usize], +} +#[test] +fn bindgen_test_layout___pthread_cond_s() { + const UNINIT: ::core::mem::MaybeUninit<__pthread_cond_s> =3D ::core::m= em::MaybeUninit::uninit(); + let ptr =3D UNINIT.as_ptr(); + assert_eq!( + ::core::mem::size_of::<__pthread_cond_s>(), + 48usize, + concat!("Size of: ", stringify!(__pthread_cond_s)) + ); + assert_eq!( + ::core::mem::align_of::<__pthread_cond_s>(), + 8usize, + concat!("Alignment of ", stringify!(__pthread_cond_s)) + ); + assert_eq!( + unsafe { ::core::ptr::addr_of!((*ptr).__wseq) as usize - ptr as us= ize }, + 0usize, + concat!( + "Offset of field: ", + stringify!(__pthread_cond_s), + "::", + stringify!(__wseq) + ) + ); + assert_eq!( + unsafe { ::core::ptr::addr_of!((*ptr).__g1_start) as usize - ptr a= s usize }, + 8usize, + concat!( + "Offset of field: ", + stringify!(__pthread_cond_s), + "::", + stringify!(__g1_start) + ) + ); + assert_eq!( + unsafe { ::core::ptr::addr_of!((*ptr).__g_refs) as usize - ptr as = usize }, + 16usize, + concat!( + "Offset of field: ", + stringify!(__pthread_cond_s), + "::", + stringify!(__g_refs) + ) + ); + assert_eq!( + unsafe { ::core::ptr::addr_of!((*ptr).__g_size) as usize - ptr as = usize }, + 24usize, + concat!( + "Offset of field: ", + stringify!(__pthread_cond_s), + "::", + stringify!(__g_size) + ) + ); + assert_eq!( + unsafe { ::core::ptr::addr_of!((*ptr).__g1_orig_size) as usize - p= tr as usize }, + 32usize, + concat!( + "Offset of field: ", + stringify!(__pthread_cond_s), + "::", + stringify!(__g1_orig_size) + ) + ); + assert_eq!( + unsafe { ::core::ptr::addr_of!((*ptr).__wrefs) as usize - ptr as u= size }, + 36usize, + concat!( + "Offset of field: ", + stringify!(__pthread_cond_s), + "::", + stringify!(__wrefs) + ) + ); + assert_eq!( + unsafe { ::core::ptr::addr_of!((*ptr).__g_signals) as usize - ptr = as usize }, + 40usize, + concat!( + "Offset of field: ", + stringify!(__pthread_cond_s), + "::", + stringify!(__g_signals) + ) + ); +} +impl Default for __pthread_cond_s { + fn default() -> Self { + let mut s =3D ::core::mem::MaybeUninit::::uninit(); + unsafe { + ::core::ptr::write_bytes(s.as_mut_ptr(), 0, 1); + s.assume_init() + } + } +} +impl ::core::fmt::Debug for __pthread_cond_s { + fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Resu= lt { + write ! (f , "__pthread_cond_s {{ __wseq: {:?}, __g1_start: {:?}, = __g_refs: {:?}, __g_size: {:?}, __g1_orig_size: {:?}, __wrefs: {:?}, __g_si= gnals: {:?} }}" , self . __wseq , self . __g1_start , self . __g_refs , sel= f . __g_size , self . __g1_orig_size , self . __wrefs , self . __g_signals) + } +} +pub type __tss_t =3D core::ffi::c_uint; +pub type __thrd_t =3D core::ffi::c_ulong; +#[repr(C)] +#[derive(Debug, Default, Copy, Clone)] +pub struct __once_flag { + pub __data: core::ffi::c_int, +} +#[test] +fn bindgen_test_layout___once_flag() { + const UNINIT: ::core::mem::MaybeUninit<__once_flag> =3D ::core::mem::M= aybeUninit::uninit(); + let ptr =3D UNINIT.as_ptr(); + assert_eq!( + ::core::mem::size_of::<__once_flag>(), + 4usize, + concat!("Size of: ", stringify!(__once_flag)) + ); + assert_eq!( + ::core::mem::align_of::<__once_flag>(), + 4usize, + concat!("Alignment of ", stringify!(__once_flag)) + ); + assert_eq!( + unsafe { ::core::ptr::addr_of!((*ptr).__data) as usize - ptr as us= ize }, + 0usize, + concat!( + "Offset of field: ", + stringify!(__once_flag), + "::", + stringify!(__data) + ) + ); +} +pub type pthread_t =3D core::ffi::c_ulong; +#[repr(C)] +#[derive(Copy, Clone)] +pub union pthread_mutexattr_t { + pub __size: [core::ffi::c_char; 4usize], + pub __align: core::ffi::c_int, +} +#[test] +fn bindgen_test_layout_pthread_mutexattr_t() { + const UNINIT: ::core::mem::MaybeUninit =3D + ::core::mem::MaybeUninit::uninit(); + let ptr =3D UNINIT.as_ptr(); + assert_eq!( + ::core::mem::size_of::(), + 4usize, + concat!("Size of: ", stringify!(pthread_mutexattr_t)) + ); + assert_eq!( + ::core::mem::align_of::(), + 4usize, + concat!("Alignment of ", stringify!(pthread_mutexattr_t)) + ); + assert_eq!( + unsafe { ::core::ptr::addr_of!((*ptr).__size) as usize - ptr as us= ize }, + 0usize, + concat!( + "Offset of field: ", + stringify!(pthread_mutexattr_t), + "::", + stringify!(__size) + ) + ); + assert_eq!( + unsafe { ::core::ptr::addr_of!((*ptr).__align) as usize - ptr as u= size }, + 0usize, + concat!( + "Offset of field: ", + stringify!(pthread_mutexattr_t), + "::", + stringify!(__align) + ) + ); +} +impl Default for pthread_mutexattr_t { + fn default() -> Self { + let mut s =3D ::core::mem::MaybeUninit::::uninit(); + unsafe { + ::core::ptr::write_bytes(s.as_mut_ptr(), 0, 1); + s.assume_init() + } + } +} +impl ::core::fmt::Debug for pthread_mutexattr_t { + fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Resu= lt { + write!(f, "pthread_mutexattr_t {{ union }}") + } +} +#[repr(C)] +#[derive(Copy, Clone)] +pub union pthread_condattr_t { + pub __size: [core::ffi::c_char; 4usize], + pub __align: core::ffi::c_int, +} +#[test] +fn bindgen_test_layout_pthread_condattr_t() { + const UNINIT: ::core::mem::MaybeUninit =3D ::core:= :mem::MaybeUninit::uninit(); + let ptr =3D UNINIT.as_ptr(); + assert_eq!( + ::core::mem::size_of::(), + 4usize, + concat!("Size of: ", stringify!(pthread_condattr_t)) + ); + assert_eq!( + ::core::mem::align_of::(), + 4usize, + concat!("Alignment of ", stringify!(pthread_condattr_t)) + ); + assert_eq!( + unsafe { ::core::ptr::addr_of!((*ptr).__size) as usize - ptr as us= ize }, + 0usize, + concat!( + "Offset of field: ", + stringify!(pthread_condattr_t), + "::", + stringify!(__size) + ) + ); + assert_eq!( + unsafe { ::core::ptr::addr_of!((*ptr).__align) as usize - ptr as u= size }, + 0usize, + concat!( + "Offset of field: ", + stringify!(pthread_condattr_t), + "::", + stringify!(__align) + ) + ); +} +impl Default for pthread_condattr_t { + fn default() -> Self { + let mut s =3D ::core::mem::MaybeUninit::::uninit(); + unsafe { + ::core::ptr::write_bytes(s.as_mut_ptr(), 0, 1); + s.assume_init() + } + } +} +impl ::core::fmt::Debug for pthread_condattr_t { + fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Resu= lt { + write!(f, "pthread_condattr_t {{ union }}") + } +} +pub type pthread_key_t =3D core::ffi::c_uint; +pub type pthread_once_t =3D core::ffi::c_int; +#[repr(C)] +#[derive(Copy, Clone)] +pub union pthread_attr_t { + pub __size: [core::ffi::c_char; 56usize], + pub __align: core::ffi::c_long, +} +#[test] +fn bindgen_test_layout_pthread_attr_t() { + const UNINIT: ::core::mem::MaybeUninit =3D ::core::mem= ::MaybeUninit::uninit(); + let ptr =3D UNINIT.as_ptr(); + assert_eq!( + ::core::mem::size_of::(), + 56usize, + concat!("Size of: ", stringify!(pthread_attr_t)) + ); + assert_eq!( + ::core::mem::align_of::(), + 8usize, + concat!("Alignment of ", stringify!(pthread_attr_t)) + ); + assert_eq!( + unsafe { ::core::ptr::addr_of!((*ptr).__size) as usize - ptr as us= ize }, + 0usize, + concat!( + "Offset of field: ", + stringify!(pthread_attr_t), + "::", + stringify!(__size) + ) + ); + assert_eq!( + unsafe { ::core::ptr::addr_of!((*ptr).__align) as usize - ptr as u= size }, + 0usize, + concat!( + "Offset of field: ", + stringify!(pthread_attr_t), + "::", + stringify!(__align) + ) + ); +} +impl Default for pthread_attr_t { + fn default() -> Self { + let mut s =3D ::core::mem::MaybeUninit::::uninit(); + unsafe { + ::core::ptr::write_bytes(s.as_mut_ptr(), 0, 1); + s.assume_init() + } + } +} +impl ::core::fmt::Debug for pthread_attr_t { + fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Resu= lt { + write!(f, "pthread_attr_t {{ union }}") + } +} +#[repr(C)] +#[derive(Copy, Clone)] +pub union pthread_mutex_t { + pub __data: __pthread_mutex_s, + pub __size: [core::ffi::c_char; 40usize], + pub __align: core::ffi::c_long, +} +#[test] +fn bindgen_test_layout_pthread_mutex_t() { + const UNINIT: ::core::mem::MaybeUninit =3D ::core::me= m::MaybeUninit::uninit(); + let ptr =3D UNINIT.as_ptr(); + assert_eq!( + ::core::mem::size_of::(), + 40usize, + concat!("Size of: ", stringify!(pthread_mutex_t)) + ); + assert_eq!( + ::core::mem::align_of::(), + 8usize, + concat!("Alignment of ", stringify!(pthread_mutex_t)) + ); + assert_eq!( + unsafe { ::core::ptr::addr_of!((*ptr).__data) as usize - ptr as us= ize }, + 0usize, + concat!( + "Offset of field: ", + stringify!(pthread_mutex_t), + "::", + stringify!(__data) + ) + ); + assert_eq!( + unsafe { ::core::ptr::addr_of!((*ptr).__size) as usize - ptr as us= ize }, + 0usize, + concat!( + "Offset of field: ", + stringify!(pthread_mutex_t), + "::", + stringify!(__size) + ) + ); + assert_eq!( + unsafe { ::core::ptr::addr_of!((*ptr).__align) as usize - ptr as u= size }, + 0usize, + concat!( + "Offset of field: ", + stringify!(pthread_mutex_t), + "::", + stringify!(__align) + ) + ); +} +impl Default for pthread_mutex_t { + fn default() -> Self { + let mut s =3D ::core::mem::MaybeUninit::::uninit(); + unsafe { + ::core::ptr::write_bytes(s.as_mut_ptr(), 0, 1); + s.assume_init() + } + } +} +impl ::core::fmt::Debug for pthread_mutex_t { + fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Resu= lt { + write!(f, "pthread_mutex_t {{ union }}") + } +} +#[repr(C)] +#[derive(Copy, Clone)] +pub union pthread_cond_t { + pub __data: __pthread_cond_s, + pub __size: [core::ffi::c_char; 48usize], + pub __align: core::ffi::c_longlong, +} +#[test] +fn bindgen_test_layout_pthread_cond_t() { + const UNINIT: ::core::mem::MaybeUninit =3D ::core::mem= ::MaybeUninit::uninit(); + let ptr =3D UNINIT.as_ptr(); + assert_eq!( + ::core::mem::size_of::(), + 48usize, + concat!("Size of: ", stringify!(pthread_cond_t)) + ); + assert_eq!( + ::core::mem::align_of::(), + 8usize, + concat!("Alignment of ", stringify!(pthread_cond_t)) + ); + assert_eq!( + unsafe { ::core::ptr::addr_of!((*ptr).__data) as usize - ptr as us= ize }, + 0usize, + concat!( + "Offset of field: ", + stringify!(pthread_cond_t), + "::", + stringify!(__data) + ) + ); + assert_eq!( + unsafe { ::core::ptr::addr_of!((*ptr).__size) as usize - ptr as us= ize }, + 0usize, + concat!( + "Offset of field: ", + stringify!(pthread_cond_t), + "::", + stringify!(__size) + ) + ); + assert_eq!( + unsafe { ::core::ptr::addr_of!((*ptr).__align) as usize - ptr as u= size }, + 0usize, + concat!( + "Offset of field: ", + stringify!(pthread_cond_t), + "::", + stringify!(__align) + ) + ); +} +impl Default for pthread_cond_t { + fn default() -> Self { + let mut s =3D ::core::mem::MaybeUninit::::uninit(); + unsafe { + ::core::ptr::write_bytes(s.as_mut_ptr(), 0, 1); + s.assume_init() + } + } +} +impl ::core::fmt::Debug for pthread_cond_t { + fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Resu= lt { + write!(f, "pthread_cond_t {{ union }}") + } +} +#[repr(C)] +#[derive(Copy, Clone)] +pub union pthread_rwlock_t { + pub __data: __pthread_rwlock_arch_t, + pub __size: [core::ffi::c_char; 56usize], + pub __align: core::ffi::c_long, +} +#[test] +fn bindgen_test_layout_pthread_rwlock_t() { + const UNINIT: ::core::mem::MaybeUninit =3D ::core::m= em::MaybeUninit::uninit(); + let ptr =3D UNINIT.as_ptr(); + assert_eq!( + ::core::mem::size_of::(), + 56usize, + concat!("Size of: ", stringify!(pthread_rwlock_t)) + ); + assert_eq!( + ::core::mem::align_of::(), + 8usize, + concat!("Alignment of ", stringify!(pthread_rwlock_t)) + ); + assert_eq!( + unsafe { ::core::ptr::addr_of!((*ptr).__data) as usize - ptr as us= ize }, + 0usize, + concat!( + "Offset of field: ", + stringify!(pthread_rwlock_t), + "::", + stringify!(__data) + ) + ); + assert_eq!( + unsafe { ::core::ptr::addr_of!((*ptr).__size) as usize - ptr as us= ize }, + 0usize, + concat!( + "Offset of field: ", + stringify!(pthread_rwlock_t), + "::", + stringify!(__size) + ) + ); + assert_eq!( + unsafe { ::core::ptr::addr_of!((*ptr).__align) as usize - ptr as u= size }, + 0usize, + concat!( + "Offset of field: ", + stringify!(pthread_rwlock_t), + "::", + stringify!(__align) + ) + ); +} +impl Default for pthread_rwlock_t { + fn default() -> Self { + let mut s =3D ::core::mem::MaybeUninit::::uninit(); + unsafe { + ::core::ptr::write_bytes(s.as_mut_ptr(), 0, 1); + s.assume_init() + } + } +} +impl ::core::fmt::Debug for pthread_rwlock_t { + fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Resu= lt { + write!(f, "pthread_rwlock_t {{ union }}") + } +} +#[repr(C)] +#[derive(Copy, Clone)] +pub union pthread_rwlockattr_t { + pub __size: [core::ffi::c_char; 8usize], + pub __align: core::ffi::c_long, +} +#[test] +fn bindgen_test_layout_pthread_rwlockattr_t() { + const UNINIT: ::core::mem::MaybeUninit =3D + ::core::mem::MaybeUninit::uninit(); + let ptr =3D UNINIT.as_ptr(); + assert_eq!( + ::core::mem::size_of::(), + 8usize, + concat!("Size of: ", stringify!(pthread_rwlockattr_t)) + ); + assert_eq!( + ::core::mem::align_of::(), + 8usize, + concat!("Alignment of ", stringify!(pthread_rwlockattr_t)) + ); + assert_eq!( + unsafe { ::core::ptr::addr_of!((*ptr).__size) as usize - ptr as us= ize }, + 0usize, + concat!( + "Offset of field: ", + stringify!(pthread_rwlockattr_t), + "::", + stringify!(__size) + ) + ); + assert_eq!( + unsafe { ::core::ptr::addr_of!((*ptr).__align) as usize - ptr as u= size }, + 0usize, + concat!( + "Offset of field: ", + stringify!(pthread_rwlockattr_t), + "::", + stringify!(__align) + ) + ); +} +impl Default for pthread_rwlockattr_t { + fn default() -> Self { + let mut s =3D ::core::mem::MaybeUninit::::uninit(); + unsafe { + ::core::ptr::write_bytes(s.as_mut_ptr(), 0, 1); + s.assume_init() + } + } +} +impl ::core::fmt::Debug for pthread_rwlockattr_t { + fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Resu= lt { + write!(f, "pthread_rwlockattr_t {{ union }}") + } +} +pub type pthread_spinlock_t =3D core::ffi::c_int; +#[repr(C)] +#[derive(Copy, Clone)] +pub union pthread_barrier_t { + pub __size: [core::ffi::c_char; 32usize], + pub __align: core::ffi::c_long, +} +#[test] +fn bindgen_test_layout_pthread_barrier_t() { + const UNINIT: ::core::mem::MaybeUninit =3D ::core::= mem::MaybeUninit::uninit(); + let ptr =3D UNINIT.as_ptr(); + assert_eq!( + ::core::mem::size_of::(), + 32usize, + concat!("Size of: ", stringify!(pthread_barrier_t)) + ); + assert_eq!( + ::core::mem::align_of::(), + 8usize, + concat!("Alignment of ", stringify!(pthread_barrier_t)) + ); + assert_eq!( + unsafe { ::core::ptr::addr_of!((*ptr).__size) as usize - ptr as us= ize }, + 0usize, + concat!( + "Offset of field: ", + stringify!(pthread_barrier_t), + "::", + stringify!(__size) + ) + ); + assert_eq!( + unsafe { ::core::ptr::addr_of!((*ptr).__align) as usize - ptr as u= size }, + 0usize, + concat!( + "Offset of field: ", + stringify!(pthread_barrier_t), + "::", + stringify!(__align) + ) + ); +} +impl Default for pthread_barrier_t { + fn default() -> Self { + let mut s =3D ::core::mem::MaybeUninit::::uninit(); + unsafe { + ::core::ptr::write_bytes(s.as_mut_ptr(), 0, 1); + s.assume_init() + } + } +} +impl ::core::fmt::Debug for pthread_barrier_t { + fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Resu= lt { + write!(f, "pthread_barrier_t {{ union }}") + } +} +#[repr(C)] +#[derive(Copy, Clone)] +pub union pthread_barrierattr_t { + pub __size: [core::ffi::c_char; 4usize], + pub __align: core::ffi::c_int, +} +#[test] +fn bindgen_test_layout_pthread_barrierattr_t() { + const UNINIT: ::core::mem::MaybeUninit =3D + ::core::mem::MaybeUninit::uninit(); + let ptr =3D UNINIT.as_ptr(); + assert_eq!( + ::core::mem::size_of::(), + 4usize, + concat!("Size of: ", stringify!(pthread_barrierattr_t)) + ); + assert_eq!( + ::core::mem::align_of::(), + 4usize, + concat!("Alignment of ", stringify!(pthread_barrierattr_t)) + ); + assert_eq!( + unsafe { ::core::ptr::addr_of!((*ptr).__size) as usize - ptr as us= ize }, + 0usize, + concat!( + "Offset of field: ", + stringify!(pthread_barrierattr_t), + "::", + stringify!(__size) + ) + ); + assert_eq!( + unsafe { ::core::ptr::addr_of!((*ptr).__align) as usize - ptr as u= size }, + 0usize, + concat!( + "Offset of field: ", + stringify!(pthread_barrierattr_t), + "::", + stringify!(__align) + ) + ); +} +impl Default for pthread_barrierattr_t { + fn default() -> Self { + let mut s =3D ::core::mem::MaybeUninit::::uninit(); + unsafe { + ::core::ptr::write_bytes(s.as_mut_ptr(), 0, 1); + s.assume_init() + } + } +} +impl ::core::fmt::Debug for pthread_barrierattr_t { + fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Resu= lt { + write!(f, "pthread_barrierattr_t {{ union }}") + } +} +pub type _Float32 =3D f32; +pub type _Float64 =3D f64; +pub type _Float32x =3D f64; +pub type _Float64x =3D u128; +#[repr(C)] +#[derive(Debug, Default, Copy, Clone)] +pub struct div_t { + pub quot: core::ffi::c_int, + pub rem: core::ffi::c_int, +} +#[test] +fn bindgen_test_layout_div_t() { + const UNINIT: ::core::mem::MaybeUninit =3D ::core::mem::MaybeUn= init::uninit(); + let ptr =3D UNINIT.as_ptr(); + assert_eq!( + ::core::mem::size_of::(), + 8usize, + concat!("Size of: ", stringify!(div_t)) + ); + assert_eq!( + ::core::mem::align_of::(), + 4usize, + concat!("Alignment of ", stringify!(div_t)) + ); + assert_eq!( + unsafe { ::core::ptr::addr_of!((*ptr).quot) as usize - ptr as usiz= e }, + 0usize, + concat!( + "Offset of field: ", + stringify!(div_t), + "::", + stringify!(quot) + ) + ); + assert_eq!( + unsafe { ::core::ptr::addr_of!((*ptr).rem) as usize - ptr as usize= }, + 4usize, + concat!( + "Offset of field: ", + stringify!(div_t), + "::", + stringify!(rem) + ) + ); +} +#[repr(C)] +#[derive(Debug, Default, Copy, Clone)] +pub struct ldiv_t { + pub quot: core::ffi::c_long, + pub rem: core::ffi::c_long, +} +#[test] +fn bindgen_test_layout_ldiv_t() { + const UNINIT: ::core::mem::MaybeUninit =3D ::core::mem::MaybeU= ninit::uninit(); + let ptr =3D UNINIT.as_ptr(); + assert_eq!( + ::core::mem::size_of::(), + 16usize, + concat!("Size of: ", stringify!(ldiv_t)) + ); + assert_eq!( + ::core::mem::align_of::(), + 8usize, + concat!("Alignment of ", stringify!(ldiv_t)) + ); + assert_eq!( + unsafe { ::core::ptr::addr_of!((*ptr).quot) as usize - ptr as usiz= e }, + 0usize, + concat!( + "Offset of field: ", + stringify!(ldiv_t), + "::", + stringify!(quot) + ) + ); + assert_eq!( + unsafe { ::core::ptr::addr_of!((*ptr).rem) as usize - ptr as usize= }, + 8usize, + concat!( + "Offset of field: ", + stringify!(ldiv_t), + "::", + stringify!(rem) + ) + ); +} +#[repr(C)] +#[derive(Debug, Default, Copy, Clone)] +pub struct lldiv_t { + pub quot: core::ffi::c_longlong, + pub rem: core::ffi::c_longlong, +} +#[test] +fn bindgen_test_layout_lldiv_t() { + const UNINIT: ::core::mem::MaybeUninit =3D ::core::mem::Maybe= Uninit::uninit(); + let ptr =3D UNINIT.as_ptr(); + assert_eq!( + ::core::mem::size_of::(), + 16usize, + concat!("Size of: ", stringify!(lldiv_t)) + ); + assert_eq!( + ::core::mem::align_of::(), + 8usize, + concat!("Alignment of ", stringify!(lldiv_t)) + ); + assert_eq!( + unsafe { ::core::ptr::addr_of!((*ptr).quot) as usize - ptr as usiz= e }, + 0usize, + concat!( + "Offset of field: ", + stringify!(lldiv_t), + "::", + stringify!(quot) + ) + ); + assert_eq!( + unsafe { ::core::ptr::addr_of!((*ptr).rem) as usize - ptr as usize= }, + 8usize, + concat!( + "Offset of field: ", + stringify!(lldiv_t), + "::", + stringify!(rem) + ) + ); +} +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct __locale_struct { + pub __locales: [*mut __locale_data; 13usize], + pub __ctype_b: *const core::ffi::c_ushort, + pub __ctype_tolower: *const core::ffi::c_int, + pub __ctype_toupper: *const core::ffi::c_int, + pub __names: [*const core::ffi::c_char; 13usize], +} +#[test] +fn bindgen_test_layout___locale_struct() { + const UNINIT: ::core::mem::MaybeUninit<__locale_struct> =3D ::core::me= m::MaybeUninit::uninit(); + let ptr =3D UNINIT.as_ptr(); + assert_eq!( + ::core::mem::size_of::<__locale_struct>(), + 232usize, + concat!("Size of: ", stringify!(__locale_struct)) + ); + assert_eq!( + ::core::mem::align_of::<__locale_struct>(), + 8usize, + concat!("Alignment of ", stringify!(__locale_struct)) + ); + assert_eq!( + unsafe { ::core::ptr::addr_of!((*ptr).__locales) as usize - ptr as= usize }, + 0usize, + concat!( + "Offset of field: ", + stringify!(__locale_struct), + "::", + stringify!(__locales) + ) + ); + assert_eq!( + unsafe { ::core::ptr::addr_of!((*ptr).__ctype_b) as usize - ptr as= usize }, + 104usize, + concat!( + "Offset of field: ", + stringify!(__locale_struct), + "::", + stringify!(__ctype_b) + ) + ); + assert_eq!( + unsafe { ::core::ptr::addr_of!((*ptr).__ctype_tolower) as usize - = ptr as usize }, + 112usize, + concat!( + "Offset of field: ", + stringify!(__locale_struct), + "::", + stringify!(__ctype_tolower) + ) + ); + assert_eq!( + unsafe { ::core::ptr::addr_of!((*ptr).__ctype_toupper) as usize - = ptr as usize }, + 120usize, + concat!( + "Offset of field: ", + stringify!(__locale_struct), + "::", + stringify!(__ctype_toupper) + ) + ); + assert_eq!( + unsafe { ::core::ptr::addr_of!((*ptr).__names) as usize - ptr as u= size }, + 128usize, + concat!( + "Offset of field: ", + stringify!(__locale_struct), + "::", + stringify!(__names) + ) + ); +} +impl Default for __locale_struct { + fn default() -> Self { + let mut s =3D ::core::mem::MaybeUninit::::uninit(); + unsafe { + ::core::ptr::write_bytes(s.as_mut_ptr(), 0, 1); + s.assume_init() + } + } +} +pub type __locale_t =3D *mut __locale_struct; +pub type locale_t =3D __locale_t; +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct random_data { + pub fptr: *mut i32, + pub rptr: *mut i32, + pub state: *mut i32, + pub rand_type: core::ffi::c_int, + pub rand_deg: core::ffi::c_int, + pub rand_sep: core::ffi::c_int, + pub end_ptr: *mut i32, +} +#[test] +fn bindgen_test_layout_random_data() { + const UNINIT: ::core::mem::MaybeUninit =3D ::core::mem::M= aybeUninit::uninit(); + let ptr =3D UNINIT.as_ptr(); + assert_eq!( + ::core::mem::size_of::(), + 48usize, + concat!("Size of: ", stringify!(random_data)) + ); + assert_eq!( + ::core::mem::align_of::(), + 8usize, + concat!("Alignment of ", stringify!(random_data)) + ); + assert_eq!( + unsafe { ::core::ptr::addr_of!((*ptr).fptr) as usize - ptr as usiz= e }, + 0usize, + concat!( + "Offset of field: ", + stringify!(random_data), + "::", + stringify!(fptr) + ) + ); + assert_eq!( + unsafe { ::core::ptr::addr_of!((*ptr).rptr) as usize - ptr as usiz= e }, + 8usize, + concat!( + "Offset of field: ", + stringify!(random_data), + "::", + stringify!(rptr) + ) + ); + assert_eq!( + unsafe { ::core::ptr::addr_of!((*ptr).state) as usize - ptr as usi= ze }, + 16usize, + concat!( + "Offset of field: ", + stringify!(random_data), + "::", + stringify!(state) + ) + ); + assert_eq!( + unsafe { ::core::ptr::addr_of!((*ptr).rand_type) as usize - ptr as= usize }, + 24usize, + concat!( + "Offset of field: ", + stringify!(random_data), + "::", + stringify!(rand_type) + ) + ); + assert_eq!( + unsafe { ::core::ptr::addr_of!((*ptr).rand_deg) as usize - ptr as = usize }, + 28usize, + concat!( + "Offset of field: ", + stringify!(random_data), + "::", + stringify!(rand_deg) + ) + ); + assert_eq!( + unsafe { ::core::ptr::addr_of!((*ptr).rand_sep) as usize - ptr as = usize }, + 32usize, + concat!( + "Offset of field: ", + stringify!(random_data), + "::", + stringify!(rand_sep) + ) + ); + assert_eq!( + unsafe { ::core::ptr::addr_of!((*ptr).end_ptr) as usize - ptr as u= size }, + 40usize, + concat!( + "Offset of field: ", + stringify!(random_data), + "::", + stringify!(end_ptr) + ) + ); +} +impl Default for random_data { + fn default() -> Self { + let mut s =3D ::core::mem::MaybeUninit::::uninit(); + unsafe { + ::core::ptr::write_bytes(s.as_mut_ptr(), 0, 1); + s.assume_init() + } + } +} +#[repr(C)] +#[derive(Debug, Default, Copy, Clone)] +pub struct drand48_data { + pub __x: [core::ffi::c_ushort; 3usize], + pub __old_x: [core::ffi::c_ushort; 3usize], + pub __c: core::ffi::c_ushort, + pub __init: core::ffi::c_ushort, + pub __a: core::ffi::c_ulonglong, +} +#[test] +fn bindgen_test_layout_drand48_data() { + const UNINIT: ::core::mem::MaybeUninit =3D ::core::mem::= MaybeUninit::uninit(); + let ptr =3D UNINIT.as_ptr(); + assert_eq!( + ::core::mem::size_of::(), + 24usize, + concat!("Size of: ", stringify!(drand48_data)) + ); + assert_eq!( + ::core::mem::align_of::(), + 8usize, + concat!("Alignment of ", stringify!(drand48_data)) + ); + assert_eq!( + unsafe { ::core::ptr::addr_of!((*ptr).__x) as usize - ptr as usize= }, + 0usize, + concat!( + "Offset of field: ", + stringify!(drand48_data), + "::", + stringify!(__x) + ) + ); + assert_eq!( + unsafe { ::core::ptr::addr_of!((*ptr).__old_x) as usize - ptr as u= size }, + 6usize, + concat!( + "Offset of field: ", + stringify!(drand48_data), + "::", + stringify!(__old_x) + ) + ); + assert_eq!( + unsafe { ::core::ptr::addr_of!((*ptr).__c) as usize - ptr as usize= }, + 12usize, + concat!( + "Offset of field: ", + stringify!(drand48_data), + "::", + stringify!(__c) + ) + ); + assert_eq!( + unsafe { ::core::ptr::addr_of!((*ptr).__init) as usize - ptr as us= ize }, + 14usize, + concat!( + "Offset of field: ", + stringify!(drand48_data), + "::", + stringify!(__init) + ) + ); + assert_eq!( + unsafe { ::core::ptr::addr_of!((*ptr).__a) as usize - ptr as usize= }, + 16usize, + concat!( + "Offset of field: ", + stringify!(drand48_data), + "::", + stringify!(__a) + ) + ); +} +pub type __compar_fn_t =3D ::core::option::Option< + unsafe extern "C" fn( + arg1: *const core::ffi::c_void, + arg2: *const core::ffi::c_void, + ) -> core::ffi::c_int, +>; +pub type comparison_fn_t =3D __compar_fn_t; +pub type __compar_d_fn_t =3D ::core::option::Option< + unsafe extern "C" fn( + arg1: *const core::ffi::c_void, + arg2: *const core::ffi::c_void, + arg3: *mut core::ffi::c_void, + ) -> core::ffi::c_int, +>; +#[repr(C)] +#[derive(Copy, Clone)] +pub struct __mbstate_t { + pub __count: core::ffi::c_int, + pub __value: __mbstate_t__bindgen_ty_1, +} +#[repr(C)] +#[derive(Copy, Clone)] +pub union __mbstate_t__bindgen_ty_1 { + pub __wch: core::ffi::c_uint, + pub __wchb: [core::ffi::c_char; 4usize], +} +#[test] +fn bindgen_test_layout___mbstate_t__bindgen_ty_1() { + const UNINIT: ::core::mem::MaybeUninit<__mbstate_t__bindgen_ty_1> =3D + ::core::mem::MaybeUninit::uninit(); + let ptr =3D UNINIT.as_ptr(); + assert_eq!( + ::core::mem::size_of::<__mbstate_t__bindgen_ty_1>(), + 4usize, + concat!("Size of: ", stringify!(__mbstate_t__bindgen_ty_1)) + ); + assert_eq!( + ::core::mem::align_of::<__mbstate_t__bindgen_ty_1>(), + 4usize, + concat!("Alignment of ", stringify!(__mbstate_t__bindgen_ty_1)) + ); + assert_eq!( + unsafe { ::core::ptr::addr_of!((*ptr).__wch) as usize - ptr as usi= ze }, + 0usize, + concat!( + "Offset of field: ", + stringify!(__mbstate_t__bindgen_ty_1), + "::", + stringify!(__wch) + ) + ); + assert_eq!( + unsafe { ::core::ptr::addr_of!((*ptr).__wchb) as usize - ptr as us= ize }, + 0usize, + concat!( + "Offset of field: ", + stringify!(__mbstate_t__bindgen_ty_1), + "::", + stringify!(__wchb) + ) + ); +} +impl Default for __mbstate_t__bindgen_ty_1 { + fn default() -> Self { + let mut s =3D ::core::mem::MaybeUninit::::uninit(); + unsafe { + ::core::ptr::write_bytes(s.as_mut_ptr(), 0, 1); + s.assume_init() + } + } +} +impl ::core::fmt::Debug for __mbstate_t__bindgen_ty_1 { + fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Resu= lt { + write!(f, "__mbstate_t__bindgen_ty_1 {{ union }}") + } +} +#[test] +fn bindgen_test_layout___mbstate_t() { + const UNINIT: ::core::mem::MaybeUninit<__mbstate_t> =3D ::core::mem::M= aybeUninit::uninit(); + let ptr =3D UNINIT.as_ptr(); + assert_eq!( + ::core::mem::size_of::<__mbstate_t>(), + 8usize, + concat!("Size of: ", stringify!(__mbstate_t)) + ); + assert_eq!( + ::core::mem::align_of::<__mbstate_t>(), + 4usize, + concat!("Alignment of ", stringify!(__mbstate_t)) + ); + assert_eq!( + unsafe { ::core::ptr::addr_of!((*ptr).__count) as usize - ptr as u= size }, + 0usize, + concat!( + "Offset of field: ", + stringify!(__mbstate_t), + "::", + stringify!(__count) + ) + ); + assert_eq!( + unsafe { ::core::ptr::addr_of!((*ptr).__value) as usize - ptr as u= size }, + 4usize, + concat!( + "Offset of field: ", + stringify!(__mbstate_t), + "::", + stringify!(__value) + ) + ); +} +impl Default for __mbstate_t { + fn default() -> Self { + let mut s =3D ::core::mem::MaybeUninit::::uninit(); + unsafe { + ::core::ptr::write_bytes(s.as_mut_ptr(), 0, 1); + s.assume_init() + } + } +} +impl ::core::fmt::Debug for __mbstate_t { + fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Resu= lt { + write!( + f, + "__mbstate_t {{ __count: {:?}, __value: {:?} }}", + self.__count, self.__value + ) + } +} +#[repr(C)] +#[derive(Copy, Clone)] +pub struct _G_fpos_t { + pub __pos: __off_t, + pub __state: __mbstate_t, +} +#[test] +fn bindgen_test_layout__G_fpos_t() { + const UNINIT: ::core::mem::MaybeUninit<_G_fpos_t> =3D ::core::mem::May= beUninit::uninit(); + let ptr =3D UNINIT.as_ptr(); + assert_eq!( + ::core::mem::size_of::<_G_fpos_t>(), + 16usize, + concat!("Size of: ", stringify!(_G_fpos_t)) + ); + assert_eq!( + ::core::mem::align_of::<_G_fpos_t>(), + 8usize, + concat!("Alignment of ", stringify!(_G_fpos_t)) + ); + assert_eq!( + unsafe { ::core::ptr::addr_of!((*ptr).__pos) as usize - ptr as usi= ze }, + 0usize, + concat!( + "Offset of field: ", + stringify!(_G_fpos_t), + "::", + stringify!(__pos) + ) + ); + assert_eq!( + unsafe { ::core::ptr::addr_of!((*ptr).__state) as usize - ptr as u= size }, + 8usize, + concat!( + "Offset of field: ", + stringify!(_G_fpos_t), + "::", + stringify!(__state) + ) + ); +} +impl Default for _G_fpos_t { + fn default() -> Self { + let mut s =3D ::core::mem::MaybeUninit::::uninit(); + unsafe { + ::core::ptr::write_bytes(s.as_mut_ptr(), 0, 1); + s.assume_init() + } + } +} +impl ::core::fmt::Debug for _G_fpos_t { + fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Resu= lt { + write!( + f, + "_G_fpos_t {{ __pos: {:?}, __state: {:?} }}", + self.__pos, self.__state + ) + } +} +pub type __fpos_t =3D _G_fpos_t; +#[repr(C)] +#[derive(Copy, Clone)] +pub struct _G_fpos64_t { + pub __pos: __off64_t, + pub __state: __mbstate_t, +} +#[test] +fn bindgen_test_layout__G_fpos64_t() { + const UNINIT: ::core::mem::MaybeUninit<_G_fpos64_t> =3D ::core::mem::M= aybeUninit::uninit(); + let ptr =3D UNINIT.as_ptr(); + assert_eq!( + ::core::mem::size_of::<_G_fpos64_t>(), + 16usize, + concat!("Size of: ", stringify!(_G_fpos64_t)) + ); + assert_eq!( + ::core::mem::align_of::<_G_fpos64_t>(), + 8usize, + concat!("Alignment of ", stringify!(_G_fpos64_t)) + ); + assert_eq!( + unsafe { ::core::ptr::addr_of!((*ptr).__pos) as usize - ptr as usi= ze }, + 0usize, + concat!( + "Offset of field: ", + stringify!(_G_fpos64_t), + "::", + stringify!(__pos) + ) + ); + assert_eq!( + unsafe { ::core::ptr::addr_of!((*ptr).__state) as usize - ptr as u= size }, + 8usize, + concat!( + "Offset of field: ", + stringify!(_G_fpos64_t), + "::", + stringify!(__state) + ) + ); +} +impl Default for _G_fpos64_t { + fn default() -> Self { + let mut s =3D ::core::mem::MaybeUninit::::uninit(); + unsafe { + ::core::ptr::write_bytes(s.as_mut_ptr(), 0, 1); + s.assume_init() + } + } +} +impl ::core::fmt::Debug for _G_fpos64_t { + fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Resu= lt { + write!( + f, + "_G_fpos64_t {{ __pos: {:?}, __state: {:?} }}", + self.__pos, self.__state + ) + } +} +pub type __fpos64_t =3D _G_fpos64_t; +pub type __FILE =3D _IO_FILE; +pub type FILE =3D _IO_FILE; +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct _IO_marker { + _unused: [u8; 0], +} +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct _IO_codecvt { + _unused: [u8; 0], +} +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct _IO_wide_data { + _unused: [u8; 0], +} +pub type _IO_lock_t =3D core::ffi::c_void; +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct _IO_FILE { + pub _flags: core::ffi::c_int, + pub _IO_read_ptr: *mut core::ffi::c_char, + pub _IO_read_end: *mut core::ffi::c_char, + pub _IO_read_base: *mut core::ffi::c_char, + pub _IO_write_base: *mut core::ffi::c_char, + pub _IO_write_ptr: *mut core::ffi::c_char, + pub _IO_write_end: *mut core::ffi::c_char, + pub _IO_buf_base: *mut core::ffi::c_char, + pub _IO_buf_end: *mut core::ffi::c_char, + pub _IO_save_base: *mut core::ffi::c_char, + pub _IO_backup_base: *mut core::ffi::c_char, + pub _IO_save_end: *mut core::ffi::c_char, + pub _markers: *mut _IO_marker, + pub _chain: *mut _IO_FILE, + pub _fileno: core::ffi::c_int, + pub _flags2: core::ffi::c_int, + pub _old_offset: __off_t, + pub _cur_column: core::ffi::c_ushort, + pub _vtable_offset: core::ffi::c_schar, + pub _shortbuf: [core::ffi::c_char; 1usize], + pub _lock: *mut _IO_lock_t, + pub _offset: __off64_t, + pub _codecvt: *mut _IO_codecvt, + pub _wide_data: *mut _IO_wide_data, + pub _freeres_list: *mut _IO_FILE, + pub _freeres_buf: *mut core::ffi::c_void, + pub __pad5: usize, + pub _mode: core::ffi::c_int, + pub _unused2: [core::ffi::c_char; 20usize], +} +#[test] +fn bindgen_test_layout__IO_FILE() { + const UNINIT: ::core::mem::MaybeUninit<_IO_FILE> =3D ::core::mem::Mayb= eUninit::uninit(); + let ptr =3D UNINIT.as_ptr(); + assert_eq!( + ::core::mem::size_of::<_IO_FILE>(), + 216usize, + concat!("Size of: ", stringify!(_IO_FILE)) + ); + assert_eq!( + ::core::mem::align_of::<_IO_FILE>(), + 8usize, + concat!("Alignment of ", stringify!(_IO_FILE)) + ); + assert_eq!( + unsafe { ::core::ptr::addr_of!((*ptr)._flags) as usize - ptr as us= ize }, + 0usize, + concat!( + "Offset of field: ", + stringify!(_IO_FILE), + "::", + stringify!(_flags) + ) + ); + assert_eq!( + unsafe { ::core::ptr::addr_of!((*ptr)._IO_read_ptr) as usize - ptr= as usize }, + 8usize, + concat!( + "Offset of field: ", + stringify!(_IO_FILE), + "::", + stringify!(_IO_read_ptr) + ) + ); + assert_eq!( + unsafe { ::core::ptr::addr_of!((*ptr)._IO_read_end) as usize - ptr= as usize }, + 16usize, + concat!( + "Offset of field: ", + stringify!(_IO_FILE), + "::", + stringify!(_IO_read_end) + ) + ); + assert_eq!( + unsafe { ::core::ptr::addr_of!((*ptr)._IO_read_base) as usize - pt= r as usize }, + 24usize, + concat!( + "Offset of field: ", + stringify!(_IO_FILE), + "::", + stringify!(_IO_read_base) + ) + ); + assert_eq!( + unsafe { ::core::ptr::addr_of!((*ptr)._IO_write_base) as usize - p= tr as usize }, + 32usize, + concat!( + "Offset of field: ", + stringify!(_IO_FILE), + "::", + stringify!(_IO_write_base) + ) + ); + assert_eq!( + unsafe { ::core::ptr::addr_of!((*ptr)._IO_write_ptr) as usize - pt= r as usize }, + 40usize, + concat!( + "Offset of field: ", + stringify!(_IO_FILE), + "::", + stringify!(_IO_write_ptr) + ) + ); + assert_eq!( + unsafe { ::core::ptr::addr_of!((*ptr)._IO_write_end) as usize - pt= r as usize }, + 48usize, + concat!( + "Offset of field: ", + stringify!(_IO_FILE), + "::", + stringify!(_IO_write_end) + ) + ); + assert_eq!( + unsafe { ::core::ptr::addr_of!((*ptr)._IO_buf_base) as usize - ptr= as usize }, + 56usize, + concat!( + "Offset of field: ", + stringify!(_IO_FILE), + "::", + stringify!(_IO_buf_base) + ) + ); + assert_eq!( + unsafe { ::core::ptr::addr_of!((*ptr)._IO_buf_end) as usize - ptr = as usize }, + 64usize, + concat!( + "Offset of field: ", + stringify!(_IO_FILE), + "::", + stringify!(_IO_buf_end) + ) + ); + assert_eq!( + unsafe { ::core::ptr::addr_of!((*ptr)._IO_save_base) as usize - pt= r as usize }, + 72usize, + concat!( + "Offset of field: ", + stringify!(_IO_FILE), + "::", + stringify!(_IO_save_base) + ) + ); + assert_eq!( + unsafe { ::core::ptr::addr_of!((*ptr)._IO_backup_base) as usize - = ptr as usize }, + 80usize, + concat!( + "Offset of field: ", + stringify!(_IO_FILE), + "::", + stringify!(_IO_backup_base) + ) + ); + assert_eq!( + unsafe { ::core::ptr::addr_of!((*ptr)._IO_save_end) as usize - ptr= as usize }, + 88usize, + concat!( + "Offset of field: ", + stringify!(_IO_FILE), + "::", + stringify!(_IO_save_end) + ) + ); + assert_eq!( + unsafe { ::core::ptr::addr_of!((*ptr)._markers) as usize - ptr as = usize }, + 96usize, + concat!( + "Offset of field: ", + stringify!(_IO_FILE), + "::", + stringify!(_markers) + ) + ); + assert_eq!( + unsafe { ::core::ptr::addr_of!((*ptr)._chain) as usize - ptr as us= ize }, + 104usize, + concat!( + "Offset of field: ", + stringify!(_IO_FILE), + "::", + stringify!(_chain) + ) + ); + assert_eq!( + unsafe { ::core::ptr::addr_of!((*ptr)._fileno) as usize - ptr as u= size }, + 112usize, + concat!( + "Offset of field: ", + stringify!(_IO_FILE), + "::", + stringify!(_fileno) + ) + ); + assert_eq!( + unsafe { ::core::ptr::addr_of!((*ptr)._flags2) as usize - ptr as u= size }, + 116usize, + concat!( + "Offset of field: ", + stringify!(_IO_FILE), + "::", + stringify!(_flags2) + ) + ); + assert_eq!( + unsafe { ::core::ptr::addr_of!((*ptr)._old_offset) as usize - ptr = as usize }, + 120usize, + concat!( + "Offset of field: ", + stringify!(_IO_FILE), + "::", + stringify!(_old_offset) + ) + ); + assert_eq!( + unsafe { ::core::ptr::addr_of!((*ptr)._cur_column) as usize - ptr = as usize }, + 128usize, + concat!( + "Offset of field: ", + stringify!(_IO_FILE), + "::", + stringify!(_cur_column) + ) + ); + assert_eq!( + unsafe { ::core::ptr::addr_of!((*ptr)._vtable_offset) as usize - p= tr as usize }, + 130usize, + concat!( + "Offset of field: ", + stringify!(_IO_FILE), + "::", + stringify!(_vtable_offset) + ) + ); + assert_eq!( + unsafe { ::core::ptr::addr_of!((*ptr)._shortbuf) as usize - ptr as= usize }, + 131usize, + concat!( + "Offset of field: ", + stringify!(_IO_FILE), + "::", + stringify!(_shortbuf) + ) + ); + assert_eq!( + unsafe { ::core::ptr::addr_of!((*ptr)._lock) as usize - ptr as usi= ze }, + 136usize, + concat!( + "Offset of field: ", + stringify!(_IO_FILE), + "::", + stringify!(_lock) + ) + ); + assert_eq!( + unsafe { ::core::ptr::addr_of!((*ptr)._offset) as usize - ptr as u= size }, + 144usize, + concat!( + "Offset of field: ", + stringify!(_IO_FILE), + "::", + stringify!(_offset) + ) + ); + assert_eq!( + unsafe { ::core::ptr::addr_of!((*ptr)._codecvt) as usize - ptr as = usize }, + 152usize, + concat!( + "Offset of field: ", + stringify!(_IO_FILE), + "::", + stringify!(_codecvt) + ) + ); + assert_eq!( + unsafe { ::core::ptr::addr_of!((*ptr)._wide_data) as usize - ptr a= s usize }, + 160usize, + concat!( + "Offset of field: ", + stringify!(_IO_FILE), + "::", + stringify!(_wide_data) + ) + ); + assert_eq!( + unsafe { ::core::ptr::addr_of!((*ptr)._freeres_list) as usize - pt= r as usize }, + 168usize, + concat!( + "Offset of field: ", + stringify!(_IO_FILE), + "::", + stringify!(_freeres_list) + ) + ); + assert_eq!( + unsafe { ::core::ptr::addr_of!((*ptr)._freeres_buf) as usize - ptr= as usize }, + 176usize, + concat!( + "Offset of field: ", + stringify!(_IO_FILE), + "::", + stringify!(_freeres_buf) + ) + ); + assert_eq!( + unsafe { ::core::ptr::addr_of!((*ptr).__pad5) as usize - ptr as us= ize }, + 184usize, + concat!( + "Offset of field: ", + stringify!(_IO_FILE), + "::", + stringify!(__pad5) + ) + ); + assert_eq!( + unsafe { ::core::ptr::addr_of!((*ptr)._mode) as usize - ptr as usi= ze }, + 192usize, + concat!( + "Offset of field: ", + stringify!(_IO_FILE), + "::", + stringify!(_mode) + ) + ); + assert_eq!( + unsafe { ::core::ptr::addr_of!((*ptr)._unused2) as usize - ptr as = usize }, + 196usize, + concat!( + "Offset of field: ", + stringify!(_IO_FILE), + "::", + stringify!(_unused2) + ) + ); +} +impl Default for _IO_FILE { + fn default() -> Self { + let mut s =3D ::core::mem::MaybeUninit::::uninit(); + unsafe { + ::core::ptr::write_bytes(s.as_mut_ptr(), 0, 1); + s.assume_init() + } + } +} +pub type cookie_read_function_t =3D ::core::option::Option< + unsafe extern "C" fn( + __cookie: *mut core::ffi::c_void, + __buf: *mut core::ffi::c_char, + __nbytes: usize, + ) -> __ssize_t, +>; +pub type cookie_write_function_t =3D ::core::option::Option< + unsafe extern "C" fn( + __cookie: *mut core::ffi::c_void, + __buf: *const core::ffi::c_char, + __nbytes: usize, + ) -> __ssize_t, +>; +pub type cookie_seek_function_t =3D ::core::option::Option< + unsafe extern "C" fn( + __cookie: *mut core::ffi::c_void, + __pos: *mut __off64_t, + __w: core::ffi::c_int, + ) -> core::ffi::c_int, +>; +pub type cookie_close_function_t =3D ::core::option::Option< + unsafe extern "C" fn(__cookie: *mut core::ffi::c_void) -> core::ffi::c= _int, +>; +#[repr(C)] +#[derive(Debug, Default, Copy, Clone)] +pub struct _IO_cookie_io_functions_t { + pub read: cookie_read_function_t, + pub write: cookie_write_function_t, + pub seek: cookie_seek_function_t, + pub close: cookie_close_function_t, +} +#[test] +fn bindgen_test_layout__IO_cookie_io_functions_t() { + const UNINIT: ::core::mem::MaybeUninit<_IO_cookie_io_functions_t> =3D + ::core::mem::MaybeUninit::uninit(); + let ptr =3D UNINIT.as_ptr(); + assert_eq!( + ::core::mem::size_of::<_IO_cookie_io_functions_t>(), + 32usize, + concat!("Size of: ", stringify!(_IO_cookie_io_functions_t)) + ); + assert_eq!( + ::core::mem::align_of::<_IO_cookie_io_functions_t>(), + 8usize, + concat!("Alignment of ", stringify!(_IO_cookie_io_functions_t)) + ); + assert_eq!( + unsafe { ::core::ptr::addr_of!((*ptr).read) as usize - ptr as usiz= e }, + 0usize, + concat!( + "Offset of field: ", + stringify!(_IO_cookie_io_functions_t), + "::", + stringify!(read) + ) + ); + assert_eq!( + unsafe { ::core::ptr::addr_of!((*ptr).write) as usize - ptr as usi= ze }, + 8usize, + concat!( + "Offset of field: ", + stringify!(_IO_cookie_io_functions_t), + "::", + stringify!(write) + ) + ); + assert_eq!( + unsafe { ::core::ptr::addr_of!((*ptr).seek) as usize - ptr as usiz= e }, + 16usize, + concat!( + "Offset of field: ", + stringify!(_IO_cookie_io_functions_t), + "::", + stringify!(seek) + ) + ); + assert_eq!( + unsafe { ::core::ptr::addr_of!((*ptr).close) as usize - ptr as usi= ze }, + 24usize, + concat!( + "Offset of field: ", + stringify!(_IO_cookie_io_functions_t), + "::", + stringify!(close) + ) + ); +} +pub type cookie_io_functions_t =3D _IO_cookie_io_functions_t; +pub type socklen_t =3D __socklen_t; +pub const _PC_LINK_MAX: _bindgen_ty_1 =3D 0; +pub const _PC_MAX_CANON: _bindgen_ty_1 =3D 1; +pub const _PC_MAX_INPUT: _bindgen_ty_1 =3D 2; +pub const _PC_NAME_MAX: _bindgen_ty_1 =3D 3; +pub const _PC_PATH_MAX: _bindgen_ty_1 =3D 4; +pub const _PC_PIPE_BUF: _bindgen_ty_1 =3D 5; +pub const _PC_CHOWN_RESTRICTED: _bindgen_ty_1 =3D 6; +pub const _PC_NO_TRUNC: _bindgen_ty_1 =3D 7; +pub const _PC_VDISABLE: _bindgen_ty_1 =3D 8; +pub const _PC_SYNC_IO: _bindgen_ty_1 =3D 9; +pub const _PC_ASYNC_IO: _bindgen_ty_1 =3D 10; +pub const _PC_PRIO_IO: _bindgen_ty_1 =3D 11; +pub const _PC_SOCK_MAXBUF: _bindgen_ty_1 =3D 12; +pub const _PC_FILESIZEBITS: _bindgen_ty_1 =3D 13; +pub const _PC_REC_INCR_XFER_SIZE: _bindgen_ty_1 =3D 14; +pub const _PC_REC_MAX_XFER_SIZE: _bindgen_ty_1 =3D 15; +pub const _PC_REC_MIN_XFER_SIZE: _bindgen_ty_1 =3D 16; +pub const _PC_REC_XFER_ALIGN: _bindgen_ty_1 =3D 17; +pub const _PC_ALLOC_SIZE_MIN: _bindgen_ty_1 =3D 18; +pub const _PC_SYMLINK_MAX: _bindgen_ty_1 =3D 19; +pub const _PC_2_SYMLINKS: _bindgen_ty_1 =3D 20; +pub type _bindgen_ty_1 =3D core::ffi::c_uint; +pub const _SC_ARG_MAX: _bindgen_ty_2 =3D 0; +pub const _SC_CHILD_MAX: _bindgen_ty_2 =3D 1; +pub const _SC_CLK_TCK: _bindgen_ty_2 =3D 2; +pub const _SC_NGROUPS_MAX: _bindgen_ty_2 =3D 3; +pub const _SC_OPEN_MAX: _bindgen_ty_2 =3D 4; +pub const _SC_STREAM_MAX: _bindgen_ty_2 =3D 5; +pub const _SC_TZNAME_MAX: _bindgen_ty_2 =3D 6; +pub const _SC_JOB_CONTROL: _bindgen_ty_2 =3D 7; +pub const _SC_SAVED_IDS: _bindgen_ty_2 =3D 8; +pub const _SC_REALTIME_SIGNALS: _bindgen_ty_2 =3D 9; +pub const _SC_PRIORITY_SCHEDULING: _bindgen_ty_2 =3D 10; +pub const _SC_TIMERS: _bindgen_ty_2 =3D 11; +pub const _SC_ASYNCHRONOUS_IO: _bindgen_ty_2 =3D 12; +pub const _SC_PRIORITIZED_IO: _bindgen_ty_2 =3D 13; +pub const _SC_SYNCHRONIZED_IO: _bindgen_ty_2 =3D 14; +pub const _SC_FSYNC: _bindgen_ty_2 =3D 15; +pub const _SC_MAPPED_FILES: _bindgen_ty_2 =3D 16; +pub const _SC_MEMLOCK: _bindgen_ty_2 =3D 17; +pub const _SC_MEMLOCK_RANGE: _bindgen_ty_2 =3D 18; +pub const _SC_MEMORY_PROTECTION: _bindgen_ty_2 =3D 19; +pub const _SC_MESSAGE_PASSING: _bindgen_ty_2 =3D 20; +pub const _SC_SEMAPHORES: _bindgen_ty_2 =3D 21; +pub const _SC_SHARED_MEMORY_OBJECTS: _bindgen_ty_2 =3D 22; +pub const _SC_AIO_LISTIO_MAX: _bindgen_ty_2 =3D 23; +pub const _SC_AIO_MAX: _bindgen_ty_2 =3D 24; +pub const _SC_AIO_PRIO_DELTA_MAX: _bindgen_ty_2 =3D 25; +pub const _SC_DELAYTIMER_MAX: _bindgen_ty_2 =3D 26; +pub const _SC_MQ_OPEN_MAX: _bindgen_ty_2 =3D 27; +pub const _SC_MQ_PRIO_MAX: _bindgen_ty_2 =3D 28; +pub const _SC_VERSION: _bindgen_ty_2 =3D 29; +pub const _SC_PAGESIZE: _bindgen_ty_2 =3D 30; +pub const _SC_RTSIG_MAX: _bindgen_ty_2 =3D 31; +pub const _SC_SEM_NSEMS_MAX: _bindgen_ty_2 =3D 32; +pub const _SC_SEM_VALUE_MAX: _bindgen_ty_2 =3D 33; +pub const _SC_SIGQUEUE_MAX: _bindgen_ty_2 =3D 34; +pub const _SC_TIMER_MAX: _bindgen_ty_2 =3D 35; +pub const _SC_BC_BASE_MAX: _bindgen_ty_2 =3D 36; +pub const _SC_BC_DIM_MAX: _bindgen_ty_2 =3D 37; +pub const _SC_BC_SCALE_MAX: _bindgen_ty_2 =3D 38; +pub const _SC_BC_STRING_MAX: _bindgen_ty_2 =3D 39; +pub const _SC_COLL_WEIGHTS_MAX: _bindgen_ty_2 =3D 40; +pub const _SC_EQUIV_CLASS_MAX: _bindgen_ty_2 =3D 41; +pub const _SC_EXPR_NEST_MAX: _bindgen_ty_2 =3D 42; +pub const _SC_LINE_MAX: _bindgen_ty_2 =3D 43; +pub const _SC_RE_DUP_MAX: _bindgen_ty_2 =3D 44; +pub const _SC_CHARCLASS_NAME_MAX: _bindgen_ty_2 =3D 45; +pub const _SC_2_VERSION: _bindgen_ty_2 =3D 46; +pub const _SC_2_C_BIND: _bindgen_ty_2 =3D 47; +pub const _SC_2_C_DEV: _bindgen_ty_2 =3D 48; +pub const _SC_2_FORT_DEV: _bindgen_ty_2 =3D 49; +pub const _SC_2_FORT_RUN: _bindgen_ty_2 =3D 50; +pub const _SC_2_SW_DEV: _bindgen_ty_2 =3D 51; +pub const _SC_2_LOCALEDEF: _bindgen_ty_2 =3D 52; +pub const _SC_PII: _bindgen_ty_2 =3D 53; +pub const _SC_PII_XTI: _bindgen_ty_2 =3D 54; +pub const _SC_PII_SOCKET: _bindgen_ty_2 =3D 55; +pub const _SC_PII_INTERNET: _bindgen_ty_2 =3D 56; +pub const _SC_PII_OSI: _bindgen_ty_2 =3D 57; +pub const _SC_POLL: _bindgen_ty_2 =3D 58; +pub const _SC_SELECT: _bindgen_ty_2 =3D 59; +pub const _SC_UIO_MAXIOV: _bindgen_ty_2 =3D 60; +pub const _SC_IOV_MAX: _bindgen_ty_2 =3D 60; +pub const _SC_PII_INTERNET_STREAM: _bindgen_ty_2 =3D 61; +pub const _SC_PII_INTERNET_DGRAM: _bindgen_ty_2 =3D 62; +pub const _SC_PII_OSI_COTS: _bindgen_ty_2 =3D 63; +pub const _SC_PII_OSI_CLTS: _bindgen_ty_2 =3D 64; +pub const _SC_PII_OSI_M: _bindgen_ty_2 =3D 65; +pub const _SC_T_IOV_MAX: _bindgen_ty_2 =3D 66; +pub const _SC_THREADS: _bindgen_ty_2 =3D 67; +pub const _SC_THREAD_SAFE_FUNCTIONS: _bindgen_ty_2 =3D 68; +pub const _SC_GETGR_R_SIZE_MAX: _bindgen_ty_2 =3D 69; +pub const _SC_GETPW_R_SIZE_MAX: _bindgen_ty_2 =3D 70; +pub const _SC_LOGIN_NAME_MAX: _bindgen_ty_2 =3D 71; +pub const _SC_TTY_NAME_MAX: _bindgen_ty_2 =3D 72; +pub const _SC_THREAD_DESTRUCTOR_ITERATIONS: _bindgen_ty_2 =3D 73; +pub const _SC_THREAD_KEYS_MAX: _bindgen_ty_2 =3D 74; +pub const _SC_THREAD_STACK_MIN: _bindgen_ty_2 =3D 75; +pub const _SC_THREAD_THREADS_MAX: _bindgen_ty_2 =3D 76; +pub const _SC_THREAD_ATTR_STACKADDR: _bindgen_ty_2 =3D 77; +pub const _SC_THREAD_ATTR_STACKSIZE: _bindgen_ty_2 =3D 78; +pub const _SC_THREAD_PRIORITY_SCHEDULING: _bindgen_ty_2 =3D 79; +pub const _SC_THREAD_PRIO_INHERIT: _bindgen_ty_2 =3D 80; +pub const _SC_THREAD_PRIO_PROTECT: _bindgen_ty_2 =3D 81; +pub const _SC_THREAD_PROCESS_SHARED: _bindgen_ty_2 =3D 82; +pub const _SC_NPROCESSORS_CONF: _bindgen_ty_2 =3D 83; +pub const _SC_NPROCESSORS_ONLN: _bindgen_ty_2 =3D 84; +pub const _SC_PHYS_PAGES: _bindgen_ty_2 =3D 85; +pub const _SC_AVPHYS_PAGES: _bindgen_ty_2 =3D 86; +pub const _SC_ATEXIT_MAX: _bindgen_ty_2 =3D 87; +pub const _SC_PASS_MAX: _bindgen_ty_2 =3D 88; +pub const _SC_XOPEN_VERSION: _bindgen_ty_2 =3D 89; +pub const _SC_XOPEN_XCU_VERSION: _bindgen_ty_2 =3D 90; +pub const _SC_XOPEN_UNIX: _bindgen_ty_2 =3D 91; +pub const _SC_XOPEN_CRYPT: _bindgen_ty_2 =3D 92; +pub const _SC_XOPEN_ENH_I18N: _bindgen_ty_2 =3D 93; +pub const _SC_XOPEN_SHM: _bindgen_ty_2 =3D 94; +pub const _SC_2_CHAR_TERM: _bindgen_ty_2 =3D 95; +pub const _SC_2_C_VERSION: _bindgen_ty_2 =3D 96; +pub const _SC_2_UPE: _bindgen_ty_2 =3D 97; +pub const _SC_XOPEN_XPG2: _bindgen_ty_2 =3D 98; +pub const _SC_XOPEN_XPG3: _bindgen_ty_2 =3D 99; +pub const _SC_XOPEN_XPG4: _bindgen_ty_2 =3D 100; +pub const _SC_CHAR_BIT: _bindgen_ty_2 =3D 101; +pub const _SC_CHAR_MAX: _bindgen_ty_2 =3D 102; +pub const _SC_CHAR_MIN: _bindgen_ty_2 =3D 103; +pub const _SC_INT_MAX: _bindgen_ty_2 =3D 104; +pub const _SC_INT_MIN: _bindgen_ty_2 =3D 105; +pub const _SC_LONG_BIT: _bindgen_ty_2 =3D 106; +pub const _SC_WORD_BIT: _bindgen_ty_2 =3D 107; +pub const _SC_MB_LEN_MAX: _bindgen_ty_2 =3D 108; +pub const _SC_NZERO: _bindgen_ty_2 =3D 109; +pub const _SC_SSIZE_MAX: _bindgen_ty_2 =3D 110; +pub const _SC_SCHAR_MAX: _bindgen_ty_2 =3D 111; +pub const _SC_SCHAR_MIN: _bindgen_ty_2 =3D 112; +pub const _SC_SHRT_MAX: _bindgen_ty_2 =3D 113; +pub const _SC_SHRT_MIN: _bindgen_ty_2 =3D 114; +pub const _SC_UCHAR_MAX: _bindgen_ty_2 =3D 115; +pub const _SC_UINT_MAX: _bindgen_ty_2 =3D 116; +pub const _SC_ULONG_MAX: _bindgen_ty_2 =3D 117; +pub const _SC_USHRT_MAX: _bindgen_ty_2 =3D 118; +pub const _SC_NL_ARGMAX: _bindgen_ty_2 =3D 119; +pub const _SC_NL_LANGMAX: _bindgen_ty_2 =3D 120; +pub const _SC_NL_MSGMAX: _bindgen_ty_2 =3D 121; +pub const _SC_NL_NMAX: _bindgen_ty_2 =3D 122; +pub const _SC_NL_SETMAX: _bindgen_ty_2 =3D 123; +pub const _SC_NL_TEXTMAX: _bindgen_ty_2 =3D 124; +pub const _SC_XBS5_ILP32_OFF32: _bindgen_ty_2 =3D 125; +pub const _SC_XBS5_ILP32_OFFBIG: _bindgen_ty_2 =3D 126; +pub const _SC_XBS5_LP64_OFF64: _bindgen_ty_2 =3D 127; +pub const _SC_XBS5_LPBIG_OFFBIG: _bindgen_ty_2 =3D 128; +pub const _SC_XOPEN_LEGACY: _bindgen_ty_2 =3D 129; +pub const _SC_XOPEN_REALTIME: _bindgen_ty_2 =3D 130; +pub const _SC_XOPEN_REALTIME_THREADS: _bindgen_ty_2 =3D 131; +pub const _SC_ADVISORY_INFO: _bindgen_ty_2 =3D 132; +pub const _SC_BARRIERS: _bindgen_ty_2 =3D 133; +pub const _SC_BASE: _bindgen_ty_2 =3D 134; +pub const _SC_C_LANG_SUPPORT: _bindgen_ty_2 =3D 135; +pub const _SC_C_LANG_SUPPORT_R: _bindgen_ty_2 =3D 136; +pub const _SC_CLOCK_SELECTION: _bindgen_ty_2 =3D 137; +pub const _SC_CPUTIME: _bindgen_ty_2 =3D 138; +pub const _SC_THREAD_CPUTIME: _bindgen_ty_2 =3D 139; +pub const _SC_DEVICE_IO: _bindgen_ty_2 =3D 140; +pub const _SC_DEVICE_SPECIFIC: _bindgen_ty_2 =3D 141; +pub const _SC_DEVICE_SPECIFIC_R: _bindgen_ty_2 =3D 142; +pub const _SC_FD_MGMT: _bindgen_ty_2 =3D 143; +pub const _SC_FIFO: _bindgen_ty_2 =3D 144; +pub const _SC_PIPE: _bindgen_ty_2 =3D 145; +pub const _SC_FILE_ATTRIBUTES: _bindgen_ty_2 =3D 146; +pub const _SC_FILE_LOCKING: _bindgen_ty_2 =3D 147; +pub const _SC_FILE_SYSTEM: _bindgen_ty_2 =3D 148; +pub const _SC_MONOTONIC_CLOCK: _bindgen_ty_2 =3D 149; +pub const _SC_MULTI_PROCESS: _bindgen_ty_2 =3D 150; +pub const _SC_SINGLE_PROCESS: _bindgen_ty_2 =3D 151; +pub const _SC_NETWORKING: _bindgen_ty_2 =3D 152; +pub const _SC_READER_WRITER_LOCKS: _bindgen_ty_2 =3D 153; +pub const _SC_SPIN_LOCKS: _bindgen_ty_2 =3D 154; +pub const _SC_REGEXP: _bindgen_ty_2 =3D 155; +pub const _SC_REGEX_VERSION: _bindgen_ty_2 =3D 156; +pub const _SC_SHELL: _bindgen_ty_2 =3D 157; +pub const _SC_SIGNALS: _bindgen_ty_2 =3D 158; +pub const _SC_SPAWN: _bindgen_ty_2 =3D 159; +pub const _SC_SPORADIC_SERVER: _bindgen_ty_2 =3D 160; +pub const _SC_THREAD_SPORADIC_SERVER: _bindgen_ty_2 =3D 161; +pub const _SC_SYSTEM_DATABASE: _bindgen_ty_2 =3D 162; +pub const _SC_SYSTEM_DATABASE_R: _bindgen_ty_2 =3D 163; +pub const _SC_TIMEOUTS: _bindgen_ty_2 =3D 164; +pub const _SC_TYPED_MEMORY_OBJECTS: _bindgen_ty_2 =3D 165; +pub const _SC_USER_GROUPS: _bindgen_ty_2 =3D 166; +pub const _SC_USER_GROUPS_R: _bindgen_ty_2 =3D 167; +pub const _SC_2_PBS: _bindgen_ty_2 =3D 168; +pub const _SC_2_PBS_ACCOUNTING: _bindgen_ty_2 =3D 169; +pub const _SC_2_PBS_LOCATE: _bindgen_ty_2 =3D 170; +pub const _SC_2_PBS_MESSAGE: _bindgen_ty_2 =3D 171; +pub const _SC_2_PBS_TRACK: _bindgen_ty_2 =3D 172; +pub const _SC_SYMLOOP_MAX: _bindgen_ty_2 =3D 173; +pub const _SC_STREAMS: _bindgen_ty_2 =3D 174; +pub const _SC_2_PBS_CHECKPOINT: _bindgen_ty_2 =3D 175; +pub const _SC_V6_ILP32_OFF32: _bindgen_ty_2 =3D 176; +pub const _SC_V6_ILP32_OFFBIG: _bindgen_ty_2 =3D 177; +pub const _SC_V6_LP64_OFF64: _bindgen_ty_2 =3D 178; +pub const _SC_V6_LPBIG_OFFBIG: _bindgen_ty_2 =3D 179; +pub const _SC_HOST_NAME_MAX: _bindgen_ty_2 =3D 180; +pub const _SC_TRACE: _bindgen_ty_2 =3D 181; +pub const _SC_TRACE_EVENT_FILTER: _bindgen_ty_2 =3D 182; +pub const _SC_TRACE_INHERIT: _bindgen_ty_2 =3D 183; +pub const _SC_TRACE_LOG: _bindgen_ty_2 =3D 184; +pub const _SC_LEVEL1_ICACHE_SIZE: _bindgen_ty_2 =3D 185; +pub const _SC_LEVEL1_ICACHE_ASSOC: _bindgen_ty_2 =3D 186; +pub const _SC_LEVEL1_ICACHE_LINESIZE: _bindgen_ty_2 =3D 187; +pub const _SC_LEVEL1_DCACHE_SIZE: _bindgen_ty_2 =3D 188; +pub const _SC_LEVEL1_DCACHE_ASSOC: _bindgen_ty_2 =3D 189; +pub const _SC_LEVEL1_DCACHE_LINESIZE: _bindgen_ty_2 =3D 190; +pub const _SC_LEVEL2_CACHE_SIZE: _bindgen_ty_2 =3D 191; +pub const _SC_LEVEL2_CACHE_ASSOC: _bindgen_ty_2 =3D 192; +pub const _SC_LEVEL2_CACHE_LINESIZE: _bindgen_ty_2 =3D 193; +pub const _SC_LEVEL3_CACHE_SIZE: _bindgen_ty_2 =3D 194; +pub const _SC_LEVEL3_CACHE_ASSOC: _bindgen_ty_2 =3D 195; +pub const _SC_LEVEL3_CACHE_LINESIZE: _bindgen_ty_2 =3D 196; +pub const _SC_LEVEL4_CACHE_SIZE: _bindgen_ty_2 =3D 197; +pub const _SC_LEVEL4_CACHE_ASSOC: _bindgen_ty_2 =3D 198; +pub const _SC_LEVEL4_CACHE_LINESIZE: _bindgen_ty_2 =3D 199; +pub const _SC_IPV6: _bindgen_ty_2 =3D 235; +pub const _SC_RAW_SOCKETS: _bindgen_ty_2 =3D 236; +pub const _SC_V7_ILP32_OFF32: _bindgen_ty_2 =3D 237; +pub const _SC_V7_ILP32_OFFBIG: _bindgen_ty_2 =3D 238; +pub const _SC_V7_LP64_OFF64: _bindgen_ty_2 =3D 239; +pub const _SC_V7_LPBIG_OFFBIG: _bindgen_ty_2 =3D 240; +pub const _SC_SS_REPL_MAX: _bindgen_ty_2 =3D 241; +pub const _SC_TRACE_EVENT_NAME_MAX: _bindgen_ty_2 =3D 242; +pub const _SC_TRACE_NAME_MAX: _bindgen_ty_2 =3D 243; +pub const _SC_TRACE_SYS_MAX: _bindgen_ty_2 =3D 244; +pub const _SC_TRACE_USER_EVENT_MAX: _bindgen_ty_2 =3D 245; +pub const _SC_XOPEN_STREAMS: _bindgen_ty_2 =3D 246; +pub const _SC_THREAD_ROBUST_PRIO_INHERIT: _bindgen_ty_2 =3D 247; +pub const _SC_THREAD_ROBUST_PRIO_PROTECT: _bindgen_ty_2 =3D 248; +pub const _SC_MINSIGSTKSZ: _bindgen_ty_2 =3D 249; +pub const _SC_SIGSTKSZ: _bindgen_ty_2 =3D 250; +pub type _bindgen_ty_2 =3D core::ffi::c_uint; +pub const _CS_PATH: _bindgen_ty_3 =3D 0; +pub const _CS_V6_WIDTH_RESTRICTED_ENVS: _bindgen_ty_3 =3D 1; +pub const _CS_GNU_LIBC_VERSION: _bindgen_ty_3 =3D 2; +pub const _CS_GNU_LIBPTHREAD_VERSION: _bindgen_ty_3 =3D 3; +pub const _CS_V5_WIDTH_RESTRICTED_ENVS: _bindgen_ty_3 =3D 4; +pub const _CS_V7_WIDTH_RESTRICTED_ENVS: _bindgen_ty_3 =3D 5; +pub const _CS_LFS_CFLAGS: _bindgen_ty_3 =3D 1000; +pub const _CS_LFS_LDFLAGS: _bindgen_ty_3 =3D 1001; +pub const _CS_LFS_LIBS: _bindgen_ty_3 =3D 1002; +pub const _CS_LFS_LINTFLAGS: _bindgen_ty_3 =3D 1003; +pub const _CS_LFS64_CFLAGS: _bindgen_ty_3 =3D 1004; +pub const _CS_LFS64_LDFLAGS: _bindgen_ty_3 =3D 1005; +pub const _CS_LFS64_LIBS: _bindgen_ty_3 =3D 1006; +pub const _CS_LFS64_LINTFLAGS: _bindgen_ty_3 =3D 1007; +pub const _CS_XBS5_ILP32_OFF32_CFLAGS: _bindgen_ty_3 =3D 1100; +pub const _CS_XBS5_ILP32_OFF32_LDFLAGS: _bindgen_ty_3 =3D 1101; +pub const _CS_XBS5_ILP32_OFF32_LIBS: _bindgen_ty_3 =3D 1102; +pub const _CS_XBS5_ILP32_OFF32_LINTFLAGS: _bindgen_ty_3 =3D 1103; +pub const _CS_XBS5_ILP32_OFFBIG_CFLAGS: _bindgen_ty_3 =3D 1104; +pub const _CS_XBS5_ILP32_OFFBIG_LDFLAGS: _bindgen_ty_3 =3D 1105; +pub const _CS_XBS5_ILP32_OFFBIG_LIBS: _bindgen_ty_3 =3D 1106; +pub const _CS_XBS5_ILP32_OFFBIG_LINTFLAGS: _bindgen_ty_3 =3D 1107; +pub const _CS_XBS5_LP64_OFF64_CFLAGS: _bindgen_ty_3 =3D 1108; +pub const _CS_XBS5_LP64_OFF64_LDFLAGS: _bindgen_ty_3 =3D 1109; +pub const _CS_XBS5_LP64_OFF64_LIBS: _bindgen_ty_3 =3D 1110; +pub const _CS_XBS5_LP64_OFF64_LINTFLAGS: _bindgen_ty_3 =3D 1111; +pub const _CS_XBS5_LPBIG_OFFBIG_CFLAGS: _bindgen_ty_3 =3D 1112; +pub const _CS_XBS5_LPBIG_OFFBIG_LDFLAGS: _bindgen_ty_3 =3D 1113; +pub const _CS_XBS5_LPBIG_OFFBIG_LIBS: _bindgen_ty_3 =3D 1114; +pub const _CS_XBS5_LPBIG_OFFBIG_LINTFLAGS: _bindgen_ty_3 =3D 1115; +pub const _CS_POSIX_V6_ILP32_OFF32_CFLAGS: _bindgen_ty_3 =3D 1116; +pub const _CS_POSIX_V6_ILP32_OFF32_LDFLAGS: _bindgen_ty_3 =3D 1117; +pub const _CS_POSIX_V6_ILP32_OFF32_LIBS: _bindgen_ty_3 =3D 1118; +pub const _CS_POSIX_V6_ILP32_OFF32_LINTFLAGS: _bindgen_ty_3 =3D 1119; +pub const _CS_POSIX_V6_ILP32_OFFBIG_CFLAGS: _bindgen_ty_3 =3D 1120; +pub const _CS_POSIX_V6_ILP32_OFFBIG_LDFLAGS: _bindgen_ty_3 =3D 1121; +pub const _CS_POSIX_V6_ILP32_OFFBIG_LIBS: _bindgen_ty_3 =3D 1122; +pub const _CS_POSIX_V6_ILP32_OFFBIG_LINTFLAGS: _bindgen_ty_3 =3D 1123; +pub const _CS_POSIX_V6_LP64_OFF64_CFLAGS: _bindgen_ty_3 =3D 1124; +pub const _CS_POSIX_V6_LP64_OFF64_LDFLAGS: _bindgen_ty_3 =3D 1125; +pub const _CS_POSIX_V6_LP64_OFF64_LIBS: _bindgen_ty_3 =3D 1126; +pub const _CS_POSIX_V6_LP64_OFF64_LINTFLAGS: _bindgen_ty_3 =3D 1127; +pub const _CS_POSIX_V6_LPBIG_OFFBIG_CFLAGS: _bindgen_ty_3 =3D 1128; +pub const _CS_POSIX_V6_LPBIG_OFFBIG_LDFLAGS: _bindgen_ty_3 =3D 1129; +pub const _CS_POSIX_V6_LPBIG_OFFBIG_LIBS: _bindgen_ty_3 =3D 1130; +pub const _CS_POSIX_V6_LPBIG_OFFBIG_LINTFLAGS: _bindgen_ty_3 =3D 1131; +pub const _CS_POSIX_V7_ILP32_OFF32_CFLAGS: _bindgen_ty_3 =3D 1132; +pub const _CS_POSIX_V7_ILP32_OFF32_LDFLAGS: _bindgen_ty_3 =3D 1133; +pub const _CS_POSIX_V7_ILP32_OFF32_LIBS: _bindgen_ty_3 =3D 1134; +pub const _CS_POSIX_V7_ILP32_OFF32_LINTFLAGS: _bindgen_ty_3 =3D 1135; +pub const _CS_POSIX_V7_ILP32_OFFBIG_CFLAGS: _bindgen_ty_3 =3D 1136; +pub const _CS_POSIX_V7_ILP32_OFFBIG_LDFLAGS: _bindgen_ty_3 =3D 1137; +pub const _CS_POSIX_V7_ILP32_OFFBIG_LIBS: _bindgen_ty_3 =3D 1138; +pub const _CS_POSIX_V7_ILP32_OFFBIG_LINTFLAGS: _bindgen_ty_3 =3D 1139; +pub const _CS_POSIX_V7_LP64_OFF64_CFLAGS: _bindgen_ty_3 =3D 1140; +pub const _CS_POSIX_V7_LP64_OFF64_LDFLAGS: _bindgen_ty_3 =3D 1141; +pub const _CS_POSIX_V7_LP64_OFF64_LIBS: _bindgen_ty_3 =3D 1142; +pub const _CS_POSIX_V7_LP64_OFF64_LINTFLAGS: _bindgen_ty_3 =3D 1143; +pub const _CS_POSIX_V7_LPBIG_OFFBIG_CFLAGS: _bindgen_ty_3 =3D 1144; +pub const _CS_POSIX_V7_LPBIG_OFFBIG_LDFLAGS: _bindgen_ty_3 =3D 1145; +pub const _CS_POSIX_V7_LPBIG_OFFBIG_LIBS: _bindgen_ty_3 =3D 1146; +pub const _CS_POSIX_V7_LPBIG_OFFBIG_LINTFLAGS: _bindgen_ty_3 =3D 1147; +pub const _CS_V6_ENV: _bindgen_ty_3 =3D 1148; +pub const _CS_V7_ENV: _bindgen_ty_3 =3D 1149; +pub type _bindgen_ty_3 =3D core::ffi::c_uint; +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct timex { + pub modes: core::ffi::c_uint, + pub offset: __syscall_slong_t, + pub freq: __syscall_slong_t, + pub maxerror: __syscall_slong_t, + pub esterror: __syscall_slong_t, + pub status: core::ffi::c_int, + pub constant: __syscall_slong_t, + pub precision: __syscall_slong_t, + pub tolerance: __syscall_slong_t, + pub time: timeval, + pub tick: __syscall_slong_t, + pub ppsfreq: __syscall_slong_t, + pub jitter: __syscall_slong_t, + pub shift: core::ffi::c_int, + pub stabil: __syscall_slong_t, + pub jitcnt: __syscall_slong_t, + pub calcnt: __syscall_slong_t, + pub errcnt: __syscall_slong_t, + pub stbcnt: __syscall_slong_t, + pub tai: core::ffi::c_int, + pub _bitfield_align_1: [u8; 0], + pub _bitfield_1: __BindgenBitfieldUnit<[u8; 44usize]>, +} +#[test] +fn bindgen_test_layout_timex() { + const UNINIT: ::core::mem::MaybeUninit =3D ::core::mem::MaybeUn= init::uninit(); + let ptr =3D UNINIT.as_ptr(); + assert_eq!( + ::core::mem::size_of::(), + 208usize, + concat!("Size of: ", stringify!(timex)) + ); + assert_eq!( + ::core::mem::align_of::(), + 8usize, + concat!("Alignment of ", stringify!(timex)) + ); + assert_eq!( + unsafe { ::core::ptr::addr_of!((*ptr).modes) as usize - ptr as usi= ze }, + 0usize, + concat!( + "Offset of field: ", + stringify!(timex), + "::", + stringify!(modes) + ) + ); + assert_eq!( + unsafe { ::core::ptr::addr_of!((*ptr).offset) as usize - ptr as us= ize }, + 8usize, + concat!( + "Offset of field: ", + stringify!(timex), + "::", + stringify!(offset) + ) + ); + assert_eq!( + unsafe { ::core::ptr::addr_of!((*ptr).freq) as usize - ptr as usiz= e }, + 16usize, + concat!( + "Offset of field: ", + stringify!(timex), + "::", + stringify!(freq) + ) + ); + assert_eq!( + unsafe { ::core::ptr::addr_of!((*ptr).maxerror) as usize - ptr as = usize }, + 24usize, + concat!( + "Offset of field: ", + stringify!(timex), + "::", + stringify!(maxerror) + ) + ); + assert_eq!( + unsafe { ::core::ptr::addr_of!((*ptr).esterror) as usize - ptr as = usize }, + 32usize, + concat!( + "Offset of field: ", + stringify!(timex), + "::", + stringify!(esterror) + ) + ); + assert_eq!( + unsafe { ::core::ptr::addr_of!((*ptr).status) as usize - ptr as us= ize }, + 40usize, + concat!( + "Offset of field: ", + stringify!(timex), + "::", + stringify!(status) + ) + ); + assert_eq!( + unsafe { ::core::ptr::addr_of!((*ptr).constant) as usize - ptr as = usize }, + 48usize, + concat!( + "Offset of field: ", + stringify!(timex), + "::", + stringify!(constant) + ) + ); + assert_eq!( + unsafe { ::core::ptr::addr_of!((*ptr).precision) as usize - ptr as= usize }, + 56usize, + concat!( + "Offset of field: ", + stringify!(timex), + "::", + stringify!(precision) + ) + ); + assert_eq!( + unsafe { ::core::ptr::addr_of!((*ptr).tolerance) as usize - ptr as= usize }, + 64usize, + concat!( + "Offset of field: ", + stringify!(timex), + "::", + stringify!(tolerance) + ) + ); + assert_eq!( + unsafe { ::core::ptr::addr_of!((*ptr).time) as usize - ptr as usiz= e }, + 72usize, + concat!( + "Offset of field: ", + stringify!(timex), + "::", + stringify!(time) + ) + ); + assert_eq!( + unsafe { ::core::ptr::addr_of!((*ptr).tick) as usize - ptr as usiz= e }, + 88usize, + concat!( + "Offset of field: ", + stringify!(timex), + "::", + stringify!(tick) + ) + ); + assert_eq!( + unsafe { ::core::ptr::addr_of!((*ptr).ppsfreq) as usize - ptr as u= size }, + 96usize, + concat!( + "Offset of field: ", + stringify!(timex), + "::", + stringify!(ppsfreq) + ) + ); + assert_eq!( + unsafe { ::core::ptr::addr_of!((*ptr).jitter) as usize - ptr as us= ize }, + 104usize, + concat!( + "Offset of field: ", + stringify!(timex), + "::", + stringify!(jitter) + ) + ); + assert_eq!( + unsafe { ::core::ptr::addr_of!((*ptr).shift) as usize - ptr as usi= ze }, + 112usize, + concat!( + "Offset of field: ", + stringify!(timex), + "::", + stringify!(shift) + ) + ); + assert_eq!( + unsafe { ::core::ptr::addr_of!((*ptr).stabil) as usize - ptr as us= ize }, + 120usize, + concat!( + "Offset of field: ", + stringify!(timex), + "::", + stringify!(stabil) + ) + ); + assert_eq!( + unsafe { ::core::ptr::addr_of!((*ptr).jitcnt) as usize - ptr as us= ize }, + 128usize, + concat!( + "Offset of field: ", + stringify!(timex), + "::", + stringify!(jitcnt) + ) + ); + assert_eq!( + unsafe { ::core::ptr::addr_of!((*ptr).calcnt) as usize - ptr as us= ize }, + 136usize, + concat!( + "Offset of field: ", + stringify!(timex), + "::", + stringify!(calcnt) + ) + ); + assert_eq!( + unsafe { ::core::ptr::addr_of!((*ptr).errcnt) as usize - ptr as us= ize }, + 144usize, + concat!( + "Offset of field: ", + stringify!(timex), + "::", + stringify!(errcnt) + ) + ); + assert_eq!( + unsafe { ::core::ptr::addr_of!((*ptr).stbcnt) as usize - ptr as us= ize }, + 152usize, + concat!( + "Offset of field: ", + stringify!(timex), + "::", + stringify!(stbcnt) + ) + ); + assert_eq!( + unsafe { ::core::ptr::addr_of!((*ptr).tai) as usize - ptr as usize= }, + 160usize, + concat!( + "Offset of field: ", + stringify!(timex), + "::", + stringify!(tai) + ) + ); +} +impl Default for timex { + fn default() -> Self { + let mut s =3D ::core::mem::MaybeUninit::::uninit(); + unsafe { + ::core::ptr::write_bytes(s.as_mut_ptr(), 0, 1); + s.assume_init() + } + } +} +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct tm { + pub tm_sec: core::ffi::c_int, + pub tm_min: core::ffi::c_int, + pub tm_hour: core::ffi::c_int, + pub tm_mday: core::ffi::c_int, + pub tm_mon: core::ffi::c_int, + pub tm_year: core::ffi::c_int, + pub tm_wday: core::ffi::c_int, + pub tm_yday: core::ffi::c_int, + pub tm_isdst: core::ffi::c_int, + pub tm_gmtoff: core::ffi::c_long, + pub tm_zone: *const core::ffi::c_char, +} +#[test] +fn bindgen_test_layout_tm() { + const UNINIT: ::core::mem::MaybeUninit =3D ::core::mem::MaybeUnini= t::uninit(); + let ptr =3D UNINIT.as_ptr(); + assert_eq!( + ::core::mem::size_of::(), + 56usize, + concat!("Size of: ", stringify!(tm)) + ); + assert_eq!( + ::core::mem::align_of::(), + 8usize, + concat!("Alignment of ", stringify!(tm)) + ); + assert_eq!( + unsafe { ::core::ptr::addr_of!((*ptr).tm_sec) as usize - ptr as us= ize }, + 0usize, + concat!( + "Offset of field: ", + stringify!(tm), + "::", + stringify!(tm_sec) + ) + ); + assert_eq!( + unsafe { ::core::ptr::addr_of!((*ptr).tm_min) as usize - ptr as us= ize }, + 4usize, + concat!( + "Offset of field: ", + stringify!(tm), + "::", + stringify!(tm_min) + ) + ); + assert_eq!( + unsafe { ::core::ptr::addr_of!((*ptr).tm_hour) as usize - ptr as u= size }, + 8usize, + concat!( + "Offset of field: ", + stringify!(tm), + "::", + stringify!(tm_hour) + ) + ); + assert_eq!( + unsafe { ::core::ptr::addr_of!((*ptr).tm_mday) as usize - ptr as u= size }, + 12usize, + concat!( + "Offset of field: ", + stringify!(tm), + "::", + stringify!(tm_mday) + ) + ); + assert_eq!( + unsafe { ::core::ptr::addr_of!((*ptr).tm_mon) as usize - ptr as us= ize }, + 16usize, + concat!( + "Offset of field: ", + stringify!(tm), + "::", + stringify!(tm_mon) + ) + ); + assert_eq!( + unsafe { ::core::ptr::addr_of!((*ptr).tm_year) as usize - ptr as u= size }, + 20usize, + concat!( + "Offset of field: ", + stringify!(tm), + "::", + stringify!(tm_year) + ) + ); + assert_eq!( + unsafe { ::core::ptr::addr_of!((*ptr).tm_wday) as usize - ptr as u= size }, + 24usize, + concat!( + "Offset of field: ", + stringify!(tm), + "::", + stringify!(tm_wday) + ) + ); + assert_eq!( + unsafe { ::core::ptr::addr_of!((*ptr).tm_yday) as usize - ptr as u= size }, + 28usize, + concat!( + "Offset of field: ", + stringify!(tm), + "::", + stringify!(tm_yday) + ) + ); + assert_eq!( + unsafe { ::core::ptr::addr_of!((*ptr).tm_isdst) as usize - ptr as = usize }, + 32usize, + concat!( + "Offset of field: ", + stringify!(tm), + "::", + stringify!(tm_isdst) + ) + ); + assert_eq!( + unsafe { ::core::ptr::addr_of!((*ptr).tm_gmtoff) as usize - ptr as= usize }, + 40usize, + concat!( + "Offset of field: ", + stringify!(tm), + "::", + stringify!(tm_gmtoff) + ) + ); + assert_eq!( + unsafe { ::core::ptr::addr_of!((*ptr).tm_zone) as usize - ptr as u= size }, + 48usize, + concat!( + "Offset of field: ", + stringify!(tm), + "::", + stringify!(tm_zone) + ) + ); +} +impl Default for tm { + fn default() -> Self { + let mut s =3D ::core::mem::MaybeUninit::::uninit(); + unsafe { + ::core::ptr::write_bytes(s.as_mut_ptr(), 0, 1); + s.assume_init() + } + } +} +#[repr(C)] +#[derive(Debug, Default, Copy, Clone)] +pub struct itimerspec { + pub it_interval: timespec, + pub it_value: timespec, +} +#[test] +fn bindgen_test_layout_itimerspec() { + const UNINIT: ::core::mem::MaybeUninit =3D ::core::mem::Ma= ybeUninit::uninit(); + let ptr =3D UNINIT.as_ptr(); + assert_eq!( + ::core::mem::size_of::(), + 32usize, + concat!("Size of: ", stringify!(itimerspec)) + ); + assert_eq!( + ::core::mem::align_of::(), + 8usize, + concat!("Alignment of ", stringify!(itimerspec)) + ); + assert_eq!( + unsafe { ::core::ptr::addr_of!((*ptr).it_interval) as usize - ptr = as usize }, + 0usize, + concat!( + "Offset of field: ", + stringify!(itimerspec), + "::", + stringify!(it_interval) + ) + ); + assert_eq!( + unsafe { ::core::ptr::addr_of!((*ptr).it_value) as usize - ptr as = usize }, + 16usize, + concat!( + "Offset of field: ", + stringify!(itimerspec), + "::", + stringify!(it_value) + ) + ); +} +pub type error_t =3D core::ffi::c_int; +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct iovec { + pub iov_base: *mut core::ffi::c_void, + pub iov_len: usize, +} +#[test] +fn bindgen_test_layout_iovec() { + const UNINIT: ::core::mem::MaybeUninit =3D ::core::mem::MaybeUn= init::uninit(); + let ptr =3D UNINIT.as_ptr(); + assert_eq!( + ::core::mem::size_of::(), + 16usize, + concat!("Size of: ", stringify!(iovec)) + ); + assert_eq!( + ::core::mem::align_of::(), + 8usize, + concat!("Alignment of ", stringify!(iovec)) + ); + assert_eq!( + unsafe { ::core::ptr::addr_of!((*ptr).iov_base) as usize - ptr as = usize }, + 0usize, + concat!( + "Offset of field: ", + stringify!(iovec), + "::", + stringify!(iov_base) + ) + ); + assert_eq!( + unsafe { ::core::ptr::addr_of!((*ptr).iov_len) as usize - ptr as u= size }, + 8usize, + concat!( + "Offset of field: ", + stringify!(iovec), + "::", + stringify!(iov_len) + ) + ); +} +impl Default for iovec { + fn default() -> Self { + let mut s =3D ::core::mem::MaybeUninit::::uninit(); + unsafe { + ::core::ptr::write_bytes(s.as_mut_ptr(), 0, 1); + s.assume_init() + } + } +} +pub const __pid_type_F_OWNER_TID: __pid_type =3D 0; +pub const __pid_type_F_OWNER_PID: __pid_type =3D 1; +pub const __pid_type_F_OWNER_PGRP: __pid_type =3D 2; +pub const __pid_type_F_OWNER_GID: __pid_type =3D 2; +pub type __pid_type =3D core::ffi::c_uint; +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct f_owner_ex { + pub type_: __pid_type, + pub pid: __pid_t, +} +#[test] +fn bindgen_test_layout_f_owner_ex() { + const UNINIT: ::core::mem::MaybeUninit =3D ::core::mem::Ma= ybeUninit::uninit(); + let ptr =3D UNINIT.as_ptr(); + assert_eq!( + ::core::mem::size_of::(), + 8usize, + concat!("Size of: ", stringify!(f_owner_ex)) + ); + assert_eq!( + ::core::mem::align_of::(), + 4usize, + concat!("Alignment of ", stringify!(f_owner_ex)) + ); + assert_eq!( + unsafe { ::core::ptr::addr_of!((*ptr).type_) as usize - ptr as usi= ze }, + 0usize, + concat!( + "Offset of field: ", + stringify!(f_owner_ex), + "::", + stringify!(type_) + ) + ); + assert_eq!( + unsafe { ::core::ptr::addr_of!((*ptr).pid) as usize - ptr as usize= }, + 4usize, + concat!( + "Offset of field: ", + stringify!(f_owner_ex), + "::", + stringify!(pid) + ) + ); +} +impl Default for f_owner_ex { + fn default() -> Self { + let mut s =3D ::core::mem::MaybeUninit::::uninit(); + unsafe { + ::core::ptr::write_bytes(s.as_mut_ptr(), 0, 1); + s.assume_init() + } + } +} +#[repr(C)] +#[derive(Debug, Default)] +pub struct file_handle { + pub handle_bytes: core::ffi::c_uint, + pub handle_type: core::ffi::c_int, + pub f_handle: __IncompleteArrayField, +} +#[test] +fn bindgen_test_layout_file_handle() { + const UNINIT: ::core::mem::MaybeUninit =3D ::core::mem::M= aybeUninit::uninit(); + let ptr =3D UNINIT.as_ptr(); + assert_eq!( + ::core::mem::size_of::(), + 8usize, + concat!("Size of: ", stringify!(file_handle)) + ); + assert_eq!( + ::core::mem::align_of::(), + 4usize, + concat!("Alignment of ", stringify!(file_handle)) + ); + assert_eq!( + unsafe { ::core::ptr::addr_of!((*ptr).handle_bytes) as usize - ptr= as usize }, + 0usize, + concat!( + "Offset of field: ", + stringify!(file_handle), + "::", + stringify!(handle_bytes) + ) + ); + assert_eq!( + unsafe { ::core::ptr::addr_of!((*ptr).handle_type) as usize - ptr = as usize }, + 4usize, + concat!( + "Offset of field: ", + stringify!(file_handle), + "::", + stringify!(handle_type) + ) + ); + assert_eq!( + unsafe { ::core::ptr::addr_of!((*ptr).f_handle) as usize - ptr as = usize }, + 8usize, + concat!( + "Offset of field: ", + stringify!(file_handle), + "::", + stringify!(f_handle) + ) + ); +} +#[repr(C)] +#[derive(Debug, Default, Copy, Clone)] +pub struct stat { + pub st_dev: __dev_t, + pub st_ino: __ino_t, + pub st_nlink: __nlink_t, + pub st_mode: __mode_t, + pub st_uid: __uid_t, + pub st_gid: __gid_t, + pub __pad0: core::ffi::c_int, + pub st_rdev: __dev_t, + pub st_size: __off_t, + pub st_blksize: __blksize_t, + pub st_blocks: __blkcnt_t, + pub st_atim: timespec, + pub st_mtim: timespec, + pub st_ctim: timespec, + pub __glibc_reserved: [__syscall_slong_t; 3usize], +} +#[test] +fn bindgen_test_layout_stat() { + const UNINIT: ::core::mem::MaybeUninit =3D ::core::mem::MaybeUni= nit::uninit(); + let ptr =3D UNINIT.as_ptr(); + assert_eq!( + ::core::mem::size_of::(), + 144usize, + concat!("Size of: ", stringify!(stat)) + ); + assert_eq!( + ::core::mem::align_of::(), + 8usize, + concat!("Alignment of ", stringify!(stat)) + ); + assert_eq!( + unsafe { ::core::ptr::addr_of!((*ptr).st_dev) as usize - ptr as us= ize }, + 0usize, + concat!( + "Offset of field: ", + stringify!(stat), + "::", + stringify!(st_dev) + ) + ); + assert_eq!( + unsafe { ::core::ptr::addr_of!((*ptr).st_ino) as usize - ptr as us= ize }, + 8usize, + concat!( + "Offset of field: ", + stringify!(stat), + "::", + stringify!(st_ino) + ) + ); + assert_eq!( + unsafe { ::core::ptr::addr_of!((*ptr).st_nlink) as usize - ptr as = usize }, + 16usize, + concat!( + "Offset of field: ", + stringify!(stat), + "::", + stringify!(st_nlink) + ) + ); + assert_eq!( + unsafe { ::core::ptr::addr_of!((*ptr).st_mode) as usize - ptr as u= size }, + 24usize, + concat!( + "Offset of field: ", + stringify!(stat), + "::", + stringify!(st_mode) + ) + ); + assert_eq!( + unsafe { ::core::ptr::addr_of!((*ptr).st_uid) as usize - ptr as us= ize }, + 28usize, + concat!( + "Offset of field: ", + stringify!(stat), + "::", + stringify!(st_uid) + ) + ); + assert_eq!( + unsafe { ::core::ptr::addr_of!((*ptr).st_gid) as usize - ptr as us= ize }, + 32usize, + concat!( + "Offset of field: ", + stringify!(stat), + "::", + stringify!(st_gid) + ) + ); + assert_eq!( + unsafe { ::core::ptr::addr_of!((*ptr).__pad0) as usize - ptr as us= ize }, + 36usize, + concat!( + "Offset of field: ", + stringify!(stat), + "::", + stringify!(__pad0) + ) + ); + assert_eq!( + unsafe { ::core::ptr::addr_of!((*ptr).st_rdev) as usize - ptr as u= size }, + 40usize, + concat!( + "Offset of field: ", + stringify!(stat), + "::", + stringify!(st_rdev) + ) + ); + assert_eq!( + unsafe { ::core::ptr::addr_of!((*ptr).st_size) as usize - ptr as u= size }, + 48usize, + concat!( + "Offset of field: ", + stringify!(stat), + "::", + stringify!(st_size) + ) + ); + assert_eq!( + unsafe { ::core::ptr::addr_of!((*ptr).st_blksize) as usize - ptr a= s usize }, + 56usize, + concat!( + "Offset of field: ", + stringify!(stat), + "::", + stringify!(st_blksize) + ) + ); + assert_eq!( + unsafe { ::core::ptr::addr_of!((*ptr).st_blocks) as usize - ptr as= usize }, + 64usize, + concat!( + "Offset of field: ", + stringify!(stat), + "::", + stringify!(st_blocks) + ) + ); + assert_eq!( + unsafe { ::core::ptr::addr_of!((*ptr).st_atim) as usize - ptr as u= size }, + 72usize, + concat!( + "Offset of field: ", + stringify!(stat), + "::", + stringify!(st_atim) + ) + ); + assert_eq!( + unsafe { ::core::ptr::addr_of!((*ptr).st_mtim) as usize - ptr as u= size }, + 88usize, + concat!( + "Offset of field: ", + stringify!(stat), + "::", + stringify!(st_mtim) + ) + ); + assert_eq!( + unsafe { ::core::ptr::addr_of!((*ptr).st_ctim) as usize - ptr as u= size }, + 104usize, + concat!( + "Offset of field: ", + stringify!(stat), + "::", + stringify!(st_ctim) + ) + ); + assert_eq!( + unsafe { ::core::ptr::addr_of!((*ptr).__glibc_reserved) as usize -= ptr as usize }, + 120usize, + concat!( + "Offset of field: ", + stringify!(stat), + "::", + stringify!(__glibc_reserved) + ) + ); +} +#[repr(C)] +#[derive(Debug, Default, Copy, Clone)] +pub struct stat64 { + pub st_dev: __dev_t, + pub st_ino: __ino64_t, + pub st_nlink: __nlink_t, + pub st_mode: __mode_t, + pub st_uid: __uid_t, + pub st_gid: __gid_t, + pub __pad0: core::ffi::c_int, + pub st_rdev: __dev_t, + pub st_size: __off_t, + pub st_blksize: __blksize_t, + pub st_blocks: __blkcnt64_t, + pub st_atim: timespec, + pub st_mtim: timespec, + pub st_ctim: timespec, + pub __glibc_reserved: [__syscall_slong_t; 3usize], +} +#[test] +fn bindgen_test_layout_stat64() { + const UNINIT: ::core::mem::MaybeUninit =3D ::core::mem::MaybeU= ninit::uninit(); + let ptr =3D UNINIT.as_ptr(); + assert_eq!( + ::core::mem::size_of::(), + 144usize, + concat!("Size of: ", stringify!(stat64)) + ); + assert_eq!( + ::core::mem::align_of::(), + 8usize, + concat!("Alignment of ", stringify!(stat64)) + ); + assert_eq!( + unsafe { ::core::ptr::addr_of!((*ptr).st_dev) as usize - ptr as us= ize }, + 0usize, + concat!( + "Offset of field: ", + stringify!(stat64), + "::", + stringify!(st_dev) + ) + ); + assert_eq!( + unsafe { ::core::ptr::addr_of!((*ptr).st_ino) as usize - ptr as us= ize }, + 8usize, + concat!( + "Offset of field: ", + stringify!(stat64), + "::", + stringify!(st_ino) + ) + ); + assert_eq!( + unsafe { ::core::ptr::addr_of!((*ptr).st_nlink) as usize - ptr as = usize }, + 16usize, + concat!( + "Offset of field: ", + stringify!(stat64), + "::", + stringify!(st_nlink) + ) + ); + assert_eq!( + unsafe { ::core::ptr::addr_of!((*ptr).st_mode) as usize - ptr as u= size }, + 24usize, + concat!( + "Offset of field: ", + stringify!(stat64), + "::", + stringify!(st_mode) + ) + ); + assert_eq!( + unsafe { ::core::ptr::addr_of!((*ptr).st_uid) as usize - ptr as us= ize }, + 28usize, + concat!( + "Offset of field: ", + stringify!(stat64), + "::", + stringify!(st_uid) + ) + ); + assert_eq!( + unsafe { ::core::ptr::addr_of!((*ptr).st_gid) as usize - ptr as us= ize }, + 32usize, + concat!( + "Offset of field: ", + stringify!(stat64), + "::", + stringify!(st_gid) + ) + ); + assert_eq!( + unsafe { ::core::ptr::addr_of!((*ptr).__pad0) as usize - ptr as us= ize }, + 36usize, + concat!( + "Offset of field: ", + stringify!(stat64), + "::", + stringify!(__pad0) + ) + ); + assert_eq!( + unsafe { ::core::ptr::addr_of!((*ptr).st_rdev) as usize - ptr as u= size }, + 40usize, + concat!( + "Offset of field: ", + stringify!(stat64), + "::", + stringify!(st_rdev) + ) + ); + assert_eq!( + unsafe { ::core::ptr::addr_of!((*ptr).st_size) as usize - ptr as u= size }, + 48usize, + concat!( + "Offset of field: ", + stringify!(stat64), + "::", + stringify!(st_size) + ) + ); + assert_eq!( + unsafe { ::core::ptr::addr_of!((*ptr).st_blksize) as usize - ptr a= s usize }, + 56usize, + concat!( + "Offset of field: ", + stringify!(stat64), + "::", + stringify!(st_blksize) + ) + ); + assert_eq!( + unsafe { ::core::ptr::addr_of!((*ptr).st_blocks) as usize - ptr as= usize }, + 64usize, + concat!( + "Offset of field: ", + stringify!(stat64), + "::", + stringify!(st_blocks) + ) + ); + assert_eq!( + unsafe { ::core::ptr::addr_of!((*ptr).st_atim) as usize - ptr as u= size }, + 72usize, + concat!( + "Offset of field: ", + stringify!(stat64), + "::", + stringify!(st_atim) + ) + ); + assert_eq!( + unsafe { ::core::ptr::addr_of!((*ptr).st_mtim) as usize - ptr as u= size }, + 88usize, + concat!( + "Offset of field: ", + stringify!(stat64), + "::", + stringify!(st_mtim) + ) + ); + assert_eq!( + unsafe { ::core::ptr::addr_of!((*ptr).st_ctim) as usize - ptr as u= size }, + 104usize, + concat!( + "Offset of field: ", + stringify!(stat64), + "::", + stringify!(st_ctim) + ) + ); + assert_eq!( + unsafe { ::core::ptr::addr_of!((*ptr).__glibc_reserved) as usize -= ptr as usize }, + 120usize, + concat!( + "Offset of field: ", + stringify!(stat64), + "::", + stringify!(__glibc_reserved) + ) + ); +} +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct option { + pub name: *const core::ffi::c_char, + pub has_arg: core::ffi::c_int, + pub flag: *mut core::ffi::c_int, + pub val: core::ffi::c_int, +} +#[test] +fn bindgen_test_layout_option() { + const UNINIT: ::core::mem::MaybeUninit