runtime: add memory protection for both core0+1

LICENSE

@@ -1,165 +0,0 @@
-                   GNU LESSER GENERAL PUBLIC LICENSE
-                       Version 3, 29 June 2007
-
- Copyright (C) 2007 Free Software Foundation, Inc. <http://fsf.org/>
- Everyone is permitted to copy and distribute verbatim copies
- of this license document, but changing it is not allowed.
-
-
-  This version of the GNU Lesser General Public License incorporates
-the terms and conditions of version 3 of the GNU General Public
-License, supplemented by the additional permissions listed below.
-
-  0. Additional Definitions.
-
-  As used herein, "this License" refers to version 3 of the GNU Lesser
-General Public License, and the "GNU GPL" refers to version 3 of the GNU
-General Public License.
-
-  "The Library" refers to a covered work governed by this License,
-other than an Application or a Combined Work as defined below.
-
-  An "Application" is any work that makes use of an interface provided
-by the Library, but which is not otherwise based on the Library.
-Defining a subclass of a class defined by the Library is deemed a mode
-of using an interface provided by the Library.
-
-  A "Combined Work" is a work produced by combining or linking an
-Application with the Library.  The particular version of the Library
-with which the Combined Work was made is also called the "Linked
-Version".
-
-  The "Minimal Corresponding Source" for a Combined Work means the
-Corresponding Source for the Combined Work, excluding any source code
-for portions of the Combined Work that, considered in isolation, are
-based on the Application, and not on the Linked Version.
-
-  The "Corresponding Application Code" for a Combined Work means the
-object code and/or source code for the Application, including any data
-and utility programs needed for reproducing the Combined Work from the
-Application, but excluding the System Libraries of the Combined Work.
-
-  1. Exception to Section 3 of the GNU GPL.
-
-  You may convey a covered work under sections 3 and 4 of this License
-without being bound by section 3 of the GNU GPL.
-
-  2. Conveying Modified Versions.
-
-  If you modify a copy of the Library, and, in your modifications, a
-facility refers to a function or data to be supplied by an Application
-that uses the facility (other than as an argument passed when the
-facility is invoked), then you may convey a copy of the modified
-version:
-
-   a) under this License, provided that you make a good faith effort to
-   ensure that, in the event an Application does not supply the
-   function or data, the facility still operates, and performs
-   whatever part of its purpose remains meaningful, or
-
-   b) under the GNU GPL, with none of the additional permissions of
-   this License applicable to that copy.
-
-  3. Object Code Incorporating Material from Library Header Files.
-
-  The object code form of an Application may incorporate material from
-a header file that is part of the Library.  You may convey such object
-code under terms of your choice, provided that, if the incorporated
-material is not limited to numerical parameters, data structure
-layouts and accessors, or small macros, inline functions and templates
-(ten or fewer lines in length), you do both of the following:
-
-   a) Give prominent notice with each copy of the object code that the
-   Library is used in it and that the Library and its use are
-   covered by this License.
-
-   b) Accompany the object code with a copy of the GNU GPL and this license
-   document.
-
-  4. Combined Works.
-
-  You may convey a Combined Work under terms of your choice that,
-taken together, effectively do not restrict modification of the
-portions of the Library contained in the Combined Work and reverse
-engineering for debugging such modifications, if you also do each of
-the following:
-
-   a) Give prominent notice with each copy of the Combined Work that
-   the Library is used in it and that the Library and its use are
-   covered by this License.
-
-   b) Accompany the Combined Work with a copy of the GNU GPL and this license
-   document.
-
-   c) For a Combined Work that displays copyright notices during
-   execution, include the copyright notice for the Library among
-   these notices, as well as a reference directing the user to the
-   copies of the GNU GPL and this license document.
-
-   d) Do one of the following:
-
-       0) Convey the Minimal Corresponding Source under the terms of this
-       License, and the Corresponding Application Code in a form
-       suitable for, and under terms that permit, the user to
-       recombine or relink the Application with a modified version of
-       the Linked Version to produce a modified Combined Work, in the
-       manner specified by section 6 of the GNU GPL for conveying
-       Corresponding Source.
-
-       1) Use a suitable shared library mechanism for linking with the
-       Library.  A suitable mechanism is one that (a) uses at run time
-       a copy of the Library already present on the user's computer
-       system, and (b) will operate properly with a modified version
-       of the Library that is interface-compatible with the Linked
-       Version.
-
-   e) Provide Installation Information, but only if you would otherwise
-   be required to provide such information under section 6 of the
-   GNU GPL, and only to the extent that such information is
-   necessary to install and execute a modified version of the
-   Combined Work produced by recombining or relinking the
-   Application with a modified version of the Linked Version. (If
-   you use option 4d0, the Installation Information must accompany
-   the Minimal Corresponding Source and Corresponding Application
-   Code. If you use option 4d1, you must provide the Installation
-   Information in the manner specified by section 6 of the GNU GPL
-   for conveying Corresponding Source.)
-
-  5. Combined Libraries.
-
-  You may place library facilities that are a work based on the
-Library side by side in a single library together with other library
-facilities that are not Applications and are not covered by this
-License, and convey such a combined library under terms of your
-choice, if you do both of the following:
-
-   a) Accompany the combined library with a copy of the same work based
-   on the Library, uncombined with any other library facilities,
-   conveyed under the terms of this License.
-
-   b) Give prominent notice with the combined library that part of it
-   is a work based on the Library, and explaining where to find the
-   accompanying uncombined form of the same work.
-
-  6. Revised Versions of the GNU Lesser General Public License.
-
-  The Free Software Foundation may publish revised and/or new versions
-of the GNU Lesser General Public License from time to time. Such new
-versions will be similar in spirit to the present version, but may
-differ in detail to address new problems or concerns.
-
-  Each version is given a distinguishing version number. If the
-Library as you received it specifies that a certain numbered version
-of the GNU Lesser General Public License "or any later version"
-applies to it, you have the option of following the terms and
-conditions either of that published version or of any later version
-published by the Free Software Foundation. If the Library as you
-received it does not specify a version number of the GNU Lesser
-General Public License, you may choose any version of the GNU Lesser
-General Public License ever published by the Free Software Foundation.
-
-  If the Library as you received it specifies that a proxy can decide
-whether future versions of the GNU Lesser General Public License shall
-apply, that proxy's public statement of acceptance of any version is
-permanent authorization for you to choose that version for the
-Library.

README.md

@@ -1,34 +1,3 @@
-ARTIQ on Zynq
-=============
-
-How to use
-----------
-
-1. Install ARTIQ-6 or newer.
-2. Select the latest successful build on Hydra: https://nixbld.m-labs.hk/jobset/artiq/zynq
-3. Search for the job named ``<board>-<variant>-sd`` (for example: ``zc706-nist_clock-sd`` or ``zc706-nist_qc2-sd``).
-4. Download the ``boot.bin`` "binary distribution" and place it at the root of a FAT-formatted SD card.
-5. Optionally, create a ``config.txt`` configuration file at the root of the SD card containing ``key=value`` pairs on each line. Use the ``ip``, ``ip6`` and ``mac`` keys to respectively set the IPv4, IPv6 and MAC address of the board. Configuring an IPv6 address is entirely optional. If these keys are not found, the firmware will use default values that may or may not be compatible with your network.
-6. Insert the SD card into the board and set up the board to boot from the SD card. For the ZC706, this is achieved by placing the large DIP switch SW11 in the 00110 position.
-7. Power up the board. After the firmware starts successfully, it should respond to ping at its IP addresses, and boot messages can be observed from its UART at 115200bps.
-8. Create and use an ARTIQ device database as usual, but set ``"target": "cortexa9"`` in the arguments of the core device.
-
-Configuration
--------------
-
-Configuring the device is done using the ``config.txt`` text file at the root of the SD card, plus the contents of the ``config`` folder. When searching for a configuration key, the firmware first looks for a file named ``/config/[key].bin`` and, if it exists, returns the contents of that file. If not, it looks into ``/config.txt``, which contains a list of ``key=value`` pairs, one per line. The ``config`` folder allows configuration values that consist in binary data, such as the startup kernel.
-
-The following configuration keys are available:
-
-- ``mac``: Ethernet MAC address.
-- ``ip``: IPv4 address.
-- ``ip6``: IPv6 address.
-- ``startup``: startup kernel in ELF format (as produced by ``artiq_compile``).
-- ``rtioclk``: source of RTIO clock; valid values are ``external`` and ``internal``.
-
-Development instructions
-------------------------
-
 Configure Nix channels:
 
 ```shell
@@ -36,46 +5,22 @@ nix-channel --add https://nixbld.m-labs.hk/channel/custom/artiq/fast-beta/artiq-
 nix-channel --update
 ```
 
-Note: if you are using Nix channels the first time, you need to be aware of this bug: https://github.com/NixOS/nix/issues/3831
+Pure build with Nix:
-
-Pure build with Nix and execution on a remote JTAG server:
 
 ```shell
 nix-build -A zc706-simple-jtag  # or zc706-nist_qc2-jtag or zc706-nist_clock-jtag
 ./remote_run.sh
 ```
 
-Impure incremental build and execution on a remote JTAG server:
+Impure incremental build:
 
 ```shell
 nix-shell
 cd src
-gateware/zc706.py -g ../build/gateware  # build gateware
+./zc706.py -g ../build/gateware  # build gateware
-make                                    # build firmware
+make                             # build firmware
 cd ..
 ./remote_run.sh -i
 ```
 
-Notes:
+The impure build process can also be used on non-Nix systems.
-
-- This is known to work with Nixpkgs 20.03 and the ``nixbld.m-labs.hk`` binary substituter can also be used here (see the ARTIQ manual for the public key and instructions).
-- The impure build process is also compatible with non-Nix systems.
-- If the board is connected to the local machine, use the ``local_run.sh`` script.
-
-License
--------
-
-Copyright (C) 2019-2020 M-Labs Limited.
-
-ARTIQ is free software: you can redistribute it and/or modify
-it under the terms of the GNU Lesser General Public License as published by
-the Free Software Foundation, either version 3 of the License, or
-(at your option) any later version.
-
-ARTIQ is distributed in the hope that it will be useful,
-but WITHOUT ANY WARRANTY; without even the implied warranty of
-MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-GNU Lesser General Public License for more details.
-
-You should have received a copy of the GNU Lesser General Public License
-along with ARTIQ.  If not, see <http://www.gnu.org/licenses/>.

cargo-xbuild.nix

@@ -1,23 +0,0 @@
-{ pkgs }:
-pkgs.rustPlatform.buildRustPackage rec {
-  pname = "cargo-xbuild";
-  version = "0.5.21";
-
-  src = pkgs.fetchFromGitHub {
-    owner = "rust-osdev";
-    repo = pname;
-    rev = "v${version}";
-    sha256 = "08mpnj3l6bcm1jg22lw1gcs0lkm4320fwl4p5y1s44w64963kzf7";
-  };
-
-  patches = [ ./cargo-xbuild.patch ];
-
-  cargoSha256 = "1pj4x8y5vfpnn8vhxqqm3vicn29870r3jh0b17q3riq4vz1a2afp";
-
-  meta = with pkgs.stdenv.lib; {
-    description = "Automatically cross-compiles the sysroot crates core, compiler_builtins, and alloc";
-    homepage = "https://github.com/rust-osdev/cargo-xbuild";
-    license = with licenses; [ mit asl20 ];
-    maintainers = with maintainers; [ johntitor xrelkd ];
-  };
-}

cargo-xbuild.patch

@@ -1,13 +0,0 @@
-diff --git a/src/sysroot.rs b/src/sysroot.rs
-index 1f3c8d1..e5615ee 100644
---- a/src/sysroot.rs
-+++ b/src/sysroot.rs
-@@ -163,7 +163,7 @@ version = "0.0.0"
- edition = "2018"
- 
- [dependencies.compiler_builtins]
--version = "0.1.0"
-+git = "https://git.m-labs.hk/M-Labs/compiler-builtins-zynq.git"
- "#;
- 
-     let mut stoml = TOML.to_owned();

default.nix

@@ -1,26 +1,28 @@
+{
+  mozillaOverlay ? import (builtins.fetchTarball https://github.com/mozilla/nixpkgs-mozilla/archive/master.tar.gz),
+}:
+
 let
-  zynq-rs = (import ./zynq-rs.nix);
+  pkgs = import <nixpkgs> { overlays = [ mozillaOverlay ]; };
-  pkgs = import <nixpkgs> { overlays = [ (import "${zynq-rs}/nix/mozilla-overlay.nix") ]; };
+  rustPlatform = (import ./rustPlatform.nix { inherit pkgs; });
-  rustPlatform = (import "${zynq-rs}/nix/rust-platform.nix" { inherit pkgs; });
-  zc706-szl = (import zynq-rs).zc706-szl;
-  zc706-fsbl = import "${zynq-rs}/nix/fsbl.nix" { inherit pkgs; };
-  mkbootimage = import "${zynq-rs}/nix/mkbootimage.nix" { inherit pkgs; };
   artiqpkgs = import <artiq-fast/default.nix> { inherit pkgs; };
   vivado = import <artiq-fast/vivado.nix> { inherit pkgs; };
+  zc706-fsbl = import ./fsbl.nix { inherit pkgs; };
+  mkbootimage = (import ./mkbootimage.nix { inherit pkgs; });
   build-zc706 = { variant }: let
     firmware = rustPlatform.buildRustPackage rec {
       name = "zc706-${variant}-firmware";
       version = "0.1.0";
 
       src = ./src;
-      cargoSha256 = "10hap25cy2qgwr7b86jid73i6fp480iym29r3r97jindfxk0svi0";
+      cargoSha256 = "05x9l6vrppvhr4qphpjklq4jlhyid1y9xg6qa52s7p7564gcvg4w";
 
       nativeBuildInputs = [
         pkgs.gnumake
         (pkgs.python3.withPackages(ps: (with artiqpkgs; [ migen migen-axi misoc artiq ])))
         pkgs.cargo-xbuild
-        pkgs.llvmPackages_9.llvm
+        pkgs.llvm_9
-        pkgs.llvmPackages_9.clang-unwrapped
+        pkgs.clang_9
       ];
       buildPhase = ''
         export XARGO_RUST_SRC="${rustPlatform.rust.rustc.src}/src"
@@ -30,10 +32,10 @@ let
 
       installPhase = ''
         mkdir -p $out $out/nix-support
-        cp ../build/runtime.bin $out/runtime.bin
         cp ../build/firmware/armv7-none-eabihf/release/runtime $out/runtime.elf
-        echo file binary-dist $out/runtime.bin >> $out/nix-support/hydra-build-products
+        cp ../build/firmware/armv7-none-eabihf/release/szl $out/szl.elf
         echo file binary-dist $out/runtime.elf >> $out/nix-support/hydra-build-products
+        echo file binary-dist $out/szl.elf >> $out/nix-support/hydra-build-products
       '';
 
       doCheck = false;
@@ -47,7 +49,7 @@ let
         ];
       }
       ''
-        python ${./src/gateware}/zc706.py -g build -V ${variant}
+        python ${./src/zc706.py} -g build -V ${variant}
         mkdir -p $out $out/nix-support
         cp build/top.bit $out
         echo file binary-dist $out/top.bit >> $out/nix-support/hydra-build-products
@@ -57,8 +59,7 @@ let
     jtag = pkgs.runCommand "zc706-${variant}-jtag" {}
       ''
         mkdir $out
-        ln -s ${zc706-szl}/szl.elf $out
+        ln -s ${firmware}/szl.elf $out
-        ln -s ${firmware}/runtime.bin $out
         ln -s ${gateware}/top.bit $out
       '';
     sd = pkgs.runCommand "zc706-${variant}-sd"
@@ -70,15 +71,13 @@ let
       # can't write software (mkbootimage will segfault).
       bifdir=`mktemp -d`
       cd $bifdir
-      ln -s ${zc706-szl}/szl.elf szl.elf
+      ln -s ${firmware}/szl.elf szl.elf
-      ln -s ${firmware}/runtime.elf runtime.elf
       ln -s ${gateware}/top.bit top.bit
       cat > boot.bif << EOF
       the_ROM_image:
       {
         [bootloader]szl.elf
         top.bit
-        runtime.elf
       }
       EOF
       mkdir $out $out/nix-support
@@ -92,6 +91,7 @@ let
         buildInputs = [ mkbootimage ];
       }
       ''
+      # TODO: use self-built fsbl
       bifdir=`mktemp -d`
       cd $bifdir
       ln -s ${zc706-fsbl}/fsbl.elf fsbl.elf
@@ -121,8 +121,5 @@ in
     (build-zc706 { variant = "simple"; }) //
     (build-zc706 { variant = "nist_clock"; }) //
     (build-zc706 { variant = "nist_qc2"; }) //
-    (build-zc706 { variant = "acpki_simple"; }) //
+    { inherit zc706-fsbl; }
-    (build-zc706 { variant = "acpki_nist_clock"; }) //
-    (build-zc706 { variant = "acpki_nist_qc2"; }) //
-    { inherit zynq-rs; }
   )

examples/device_db.py

@@ -1,5 +1,3 @@
-# For NIST_QC2
-
 device_db = {
     "core": {
         "type": "local",
@@ -12,24 +10,7 @@ device_db = {
             "target": "cortexa9"
         }
     },
-    "core_cache": {
-        "type": "local",
-        "module": "artiq.coredevice.cache",
-        "class": "CoreCache"
-    },
-    "core_dma": {
-        "type": "local",
-        "module": "artiq.coredevice.dma",
-        "class": "CoreDMA"
-    },
 
-    "i2c_switch": {
-        "type": "local",
-        "module": "artiq.coredevice.i2c",
-        "class": "PCA9548"
-    },
-
-    # led? are common to all variants
     "led0": {
         "type": "local",
         "module": "artiq.coredevice.ttl",
@@ -55,33 +36,3 @@ device_db = {
         "arguments": {"channel": 3}
     },
 }
-
-# TTLs on QC2 backplane
-for i in range(40):
-    device_db["ttl" + str(i)] = {
-        "type": "local",
-        "module": "artiq.coredevice.ttl",
-        "class": "TTLInOut",
-        "arguments": {"channel": 4+i}
-    }
-
-device_db["ad9914dds0"] = {
-    "type": "local",
-    "module": "artiq.coredevice.ad9914",
-    "class": "AD9914",
-    "arguments": {"sysclk": 3e9, "bus_channel": 50, "channel": 0},
-}
-device_db["ad9914dds1"] = {
-    "type": "local",
-    "module": "artiq.coredevice.ad9914",
-    "class": "AD9914",
-    "arguments": {"sysclk": 3e9, "bus_channel": 50, "channel": 1},
-}
-
-# for ARTIQ test suite
-device_db.update(
-    loop_out="ttl0",
-    loop_in="ttl1",
-    ttl_out="ttl2",
-    ttl_out_serdes="ttl2",
-)

examples/dma.py

@@ -1,26 +0,0 @@
-from artiq.experiment import *
-
-class DMAPulses(EnvExperiment):
-    def build(self):
-        self.setattr_device("core")
-        self.setattr_device("core_dma")
-        self.setattr_device("led0")
-
-    @kernel
-    def record(self):
-        with self.core_dma.record("pulse"):
-            delay(200*ms)
-            # all RTIO operations now go to the "pulse"
-            # DMA buffer, instead of being executed immediately.
-            self.led0.pulse(500*ms)
-
-
-    @kernel
-    def run(self):
-        self.core.reset()
-        self.record()
-        # prefetch the address of the DMA buffer
-        # for faster playback trigger
-        pulse_handle = self.core_dma.get_handle("pulse")
-        self.core.break_realtime()
-        self.core_dma.playback_handle(pulse_handle)

examples/exception.py

@@ -1,38 +0,0 @@
-from artiq.experiment import *
-from artiq.language.core import TerminationRequested
-
-class ExceptionDemo(EnvExperiment):
-    def build(self):
-        self.setattr_device("core")
-        self.setattr_device("led0")
-
-    def foo(self):
-        print("raise error")
-        raise Exception
-
-    def termination(self):
-        raise TerminationRequested
-
-    @rpc
-    def remote(self):
-        raise Exception
-
-    @kernel
-    def run(self):
-        self.core.reset()
-        try:
-            try:
-                self.foo()
-            except ValueError as e:
-                print("should not trigger this")
-        except:
-            print("catch all")
-
-        try:
-            self.remote()
-        except:
-            print("Error!")
-
-        print("Uncaught error at last")
-        self.termination()
-

fsbl.nix

@@ -0,0 +1,37 @@
+{ pkgs, board ? "zc706" }:
+let
+  gnutoolchain = import ./gnutoolchain.nix { inherit pkgs; };
+in
+pkgs.stdenv.mkDerivation {
+  name = "${board}-fsbl";
+  src = pkgs.fetchFromGitHub {
+    owner = "Xilinx";
+    repo = "embeddedsw";
+    rev = "65c849ed46c88c67457e1fc742744f96db968ff1";
+    sha256 = "1rvl06ha40dzd6s9aa4sylmksh4xb9dqaxq462lffv1fdk342pda";
+  };
+  patches = [ ./fsbl.patch ];
+  nativeBuildInputs = [
+    pkgs.gnumake
+    gnutoolchain.binutils
+    gnutoolchain.gcc
+  ];
+  patchPhase =
+    ''
+    patch -p1 -i ${./fsbl.patch}
+    patchShebangs lib/sw_apps/zynq_fsbl/misc/copy_bsp.sh
+    echo 'SEARCH_DIR("${gnutoolchain.newlib}/arm-none-eabi/lib");' >> lib/sw_apps/zynq_fsbl/src/lscript.ld
+    '';
+  buildPhase =
+    ''
+    cd lib/sw_apps/zynq_fsbl/src
+    make BOARD=${board} "CFLAGS=-DFSBL_DEBUG_INFO -g"
+    '';
+  installPhase = 
+    ''
+    mkdir $out
+    cp fsbl.elf $out
+    '';
+  doCheck = false;
+  dontFixup = true;
+}

fsbl.patch

@@ -0,0 +1,31 @@
+diff --git a/lib/sw_apps/zynq_fsbl/src/Makefile b/lib/sw_apps/zynq_fsbl/src/Makefile
+index 0e3ccdf1c5..a5b02f386e 100644
+--- a/lib/sw_apps/zynq_fsbl/src/Makefile
++++ b/lib/sw_apps/zynq_fsbl/src/Makefile
+@@ -71,11 +71,14 @@ endif
+ all: $(EXEC)
+ 
+ $(EXEC): $(LIBS) $(OBJS) $(INCLUDES)
+-	cp $(BSP_DIR)/$(BOARD)/ps7_init.* .
+ 	$(LINKER) $(LD1FLAGS)  -o $@ $(OBJS) $(LDFLAGS)
+ 	rm -rf $(OBJS)
+-	
+-	
++
++.PHONY: ps7_init
++
++ps7_init:
++	cp $(BSP_DIR)/$(BOARD)/ps7_init.* .
++
+ $(LIBS): 
+ 	echo "Copying BSP files"
+ 	$(BSP_DIR)/copy_bsp.sh $(BOARD) $(CC)
+@@ -86,7 +89,7 @@ $(LIBS):
+         make -C $(BSP_DIR) -k all "CC=armcc" "AR=armar" "C_FLAGS= -O2 -c" "EC_FLAGS=--debug --wchar32"; \
+ 	fi;
+ 
+-%.o:%.c
++%.o:%.c ps7_init
+ 	$(CC) $(CC_FLAGS) $(CFLAGS) $(ECFLAGS) -c $< -o $@ $(INCLUDEPATH)
+ 
+ %.o:%.S

gnutoolchain.nix

@@ -0,0 +1,134 @@
+{ pkgs ? import <nixpkgs> }:
+let 
+
+platform = "arm-none-eabi";
+
+binutils-pkg = { stdenv, buildPackages
+, fetchurl, zlib
+, extraConfigureFlags ? []
+}:
+
+stdenv.mkDerivation rec {
+  basename = "binutils";
+  version = "2.30";
+  name = "${basename}-${platform}-${version}";
+  src = fetchurl {
+    url = "https://ftp.gnu.org/gnu/binutils/binutils-${version}.tar.bz2";
+    sha256 = "028cklfqaab24glva1ks2aqa1zxa6w6xmc8q34zs1sb7h22dxspg";
+  };
+  configureFlags = [
+    "--enable-deterministic-archives"
+    "--target=${platform}"
+    "--with-cpu=cortex-a9"
+    "--with-fpu=vfpv3"
+    "--with-float=hard"
+    "--with-mode=thumb"
+  ] ++ extraConfigureFlags;
+  outputs = [ "out" "info" "man" ];
+  depsBuildBuild = [ buildPackages.stdenv.cc ];
+  buildInputs = [ zlib ];
+  enableParallelBuilding = true;
+  meta = {
+    description = "Tools for manipulating binaries (linker, assembler, etc.)";
+    longDescription = ''
+      The GNU Binutils are a collection of binary tools.  The main
+      ones are `ld' (the GNU linker) and `as' (the GNU assembler).
+      They also include the BFD (Binary File Descriptor) library,
+      `gprof', `nm', `strip', etc.
+    '';
+    homepage = http://www.gnu.org/software/binutils/;
+    license = stdenv.lib.licenses.gpl3Plus;
+    /* Give binutils a lower priority than gcc-wrapper to prevent a
+       collision due to the ld/as wrappers/symlinks in the latter. */
+    priority = "10";
+  };
+};
+
+
+gcc-pkg = { stdenv, buildPackages
+, fetchurl, gmp, mpfr, libmpc, platform-binutils
+, extraConfigureFlags ? []
+}:
+
+stdenv.mkDerivation rec {
+  basename = "gcc";
+  version = "9.1.0";
+  name = "${basename}-${platform}-${version}";
+  src = fetchurl {
+    url = "https://ftp.gnu.org/gnu/gcc/gcc-${version}/gcc-${version}.tar.xz";
+    sha256 = "1817nc2bqdc251k0lpc51cimna7v68xjrnvqzvc50q3ax4s6i9kr";
+  };
+  preConfigure =
+    ''
+    mkdir build
+    cd build
+    '';
+  configureScript = "../configure";
+  configureFlags =
+    [ "--target=${platform}"
+      "--with-arch=armv7-a"
+      "--with-tune=cortex-a9"
+      "--with-fpu=vfpv3"
+      "--with-float=hard"
+      "--disable-libssp"
+      "--enable-languages=c"
+      "--with-as=${platform-binutils}/bin/${platform}-as"
+      "--with-ld=${platform-binutils}/bin/${platform}-ld" ] ++ extraConfigureFlags;
+  outputs = [ "out" "info" "man" ];
+  hardeningDisable = [ "format" "pie" ];
+  propagatedBuildInputs = [ gmp mpfr libmpc platform-binutils ];
+  enableParallelBuilding = true;
+  dontFixup = true;
+};
+
+
+newlib-pkg = { stdenv, fetchurl, buildPackages, platform-binutils, platform-gcc }:
+
+stdenv.mkDerivation rec {
+  pname = "newlib";
+  version = "3.1.0";
+  src = fetchurl {
+    url = "ftp://sourceware.org/pub/newlib/newlib-${version}.tar.gz";
+    sha256 = "0ahh3n079zjp7d9wynggwrnrs27440aac04340chf1p9476a2kzv";
+  };
+
+  nativeBuildInputs = [ platform-binutils platform-gcc ];
+
+  configureFlags = [
+    "--target=${platform}"
+
+    "--with-cpu=cortex-a9"
+    "--with-fpu=vfpv3"
+    "--with-float=hard"
+    "--with-mode=thumb"
+    "--enable-interwork"
+    "--disable-multilib"
+
+    "--disable-newlib-supplied-syscalls"
+    "--with-gnu-ld"
+    "--with-gnu-as"
+    "--disable-newlib-io-float"
+    "--disable-werror"
+  ];
+  dontFixup = true;
+};
+
+
+in rec {
+  binutils-bootstrap = pkgs.callPackage binutils-pkg { };
+  gcc-bootstrap = pkgs.callPackage gcc-pkg {
+    platform-binutils = binutils-bootstrap;
+    extraConfigureFlags = [ "--disable-libgcc" ];
+  };
+  newlib = pkgs.callPackage newlib-pkg {
+    platform-binutils = binutils-bootstrap;
+    platform-gcc = gcc-bootstrap;
+  };
+  binutils = pkgs.callPackage binutils-pkg {
+    extraConfigureFlags = [ "--with-lib-path=${newlib}/arm-none-eabi/lib" ];
+  };
+  gcc = pkgs.callPackage gcc-pkg {
+    platform-binutils = binutils;
+    extraConfigureFlags = [ "--enable-newlib" "--with-headers=${newlib}/arm-none-eabi/include" ];
+  };
+}

local_run.sh

@@ -2,47 +2,20 @@
 
 set -e
 
-if [ -z "$OPENOCD_ZYNQ" ]; then
-    echo "OPENOCD_ZYNQ environment variable must be set"
-    exit 1
-fi
-if [ -z "$SZL" ]; then
-    echo "SZL environment variable must be set"
-    exit 1
-fi
-
 impure=0
-load_bitstream=1
-board_host="192.168.1.52"
 
-while getopts "ilb:" opt; do
+while getopts "h:i" opt; do
     case "$opt" in
-    \?) exit 1
+    \?) exit 0
         ;;
     i)  impure=1
         ;;
-    l)  load_bitstream=0
-        ;;
-    b)  board_host=$OPTARG
-        ;;
     esac
 done
 
-load_bitstream_cmd=""
+cd openocd
-
-build_dir=`pwd`/build
-result_dir=`pwd`/result
-cd $OPENOCD_ZYNQ
-openocd -f zc706.cfg -c "load_image $SZL; resume 0; exit"
-sleep 5
 if [ $impure -eq 1 ]; then
-    if [ $load_bitstream -eq 1 ]; then
+    openocd -f zc706.cfg -c 'pld load 0 ../build/gateware/top.bit; load_image ../build/firmware/armv7-none-eabihf/release/szl; resume 0; exit'
-        load_bitstream_cmd="-g $build_dir/gateware/top.bit"
-    fi
-    artiq_netboot $load_bitstream_cmd -f $build_dir/runtime.bin -b $board_host
 else
-    if [ $load_bitstream -eq 1 ]; then
+    openocd -f zc706.cfg -c 'pld load 0 ../result/top.bit; load_image ../result/szl.elf; resume 0; exit'
-        load_bitstream_cmd="-g $result_dir/top.bit"
-    fi
-    artiq_netboot $load_bitstream_cmd -f $result_dir/runtime.bin -b $board_host
 fi

mkbootimage.nix

@@ -0,0 +1,24 @@
+{ pkgs }:
+
+pkgs.stdenv.mkDerivation {
+  pname = "mkbootimage";
+  version = "2.2";
+
+  src = pkgs.fetchFromGitHub {
+    owner = "antmicro";
+    repo = "zynq-mkbootimage";
+    rev = "4ee42d782a9ba65725ed165a4916853224a8edf7";
+    sha256 = "1k1mbsngqadqihzjgvwvsrkvryxy5ladpxd9yh9iqn2s7fxqwqa9";
+  };
+
+  propagatedBuildInputs = [ pkgs.libelf pkgs.pcre ];
+  patchPhase =
+    ''
+    substituteInPlace Makefile --replace "git rev-parse --short HEAD" "echo nix"
+    '';
+  installPhase =
+    ''
+    mkdir -p $out/bin
+    cp mkbootimage $out/bin
+    '';
+}

openocd/digilent_jtag_smt2_nc.cfg

@@ -0,0 +1,18 @@
+#
+# Digilent JTAG-SMT2-NC
+#
+# http://store.digilentinc.com/jtag-smt2-nc-surface-mount-programming-module/
+# https://reference.digilentinc.com/_media/jtag_smt2nc/jtag-smt2-nc_rm.pdf
+#
+# Based on reference sheet (above) and Xilinx KCU105 schematics
+# https://www.xilinx.com/products/boards-and-kits/kcu105.html#documentation
+#
+# Note that the digilent_jtag_smt2 layout does not work and hangs while
+# the ftdi_device_desc from digilent_hs2 is wrong.
+
+interface ftdi
+ftdi_device_desc "Digilent USB Device"
+ftdi_vid_pid 0x0403 0x6014
+ftdi_channel 0
+ftdi_layout_init 0x00e8 0x60eb
+ftdi_layout_signal nSRST -data 0x2000

openocd/ps7_init.tcl

@@ -0,0 +1,771 @@
+proc ps7_pll_init_data_3_0 {} {
+    mwr -force 0XF8000008 0x0000DF0D
+    mask_write 0XF8000110 0x003FFFF0 0x000FA220
+    mask_write 0XF8000100 0x0007F000 0x00028000
+    mask_write 0XF8000100 0x00000010 0x00000010
+    mask_write 0XF8000100 0x00000001 0x00000001
+    mask_write 0XF8000100 0x00000001 0x00000000
+    mask_poll 0XF800010C 0x00000001
+    mask_write 0XF8000100 0x00000010 0x00000000
+    mask_write 0XF8000120 0x1F003F30 0x1F000200
+    mask_write 0XF8000114 0x003FFFF0 0x0012C220
+    mask_write 0XF8000104 0x0007F000 0x00020000
+    mask_write 0XF8000104 0x00000010 0x00000010
+    mask_write 0XF8000104 0x00000001 0x00000001
+    mask_write 0XF8000104 0x00000001 0x00000000
+    mask_poll 0XF800010C 0x00000002
+    mask_write 0XF8000104 0x00000010 0x00000000
+    mask_write 0XF8000124 0xFFF00003 0x0C200003
+    mask_write 0XF8000118 0x003FFFF0 0x001452C0
+    mask_write 0XF8000108 0x0007F000 0x0001E000
+    mask_write 0XF8000108 0x00000010 0x00000010
+    mask_write 0XF8000108 0x00000001 0x00000001
+    mask_write 0XF8000108 0x00000001 0x00000000
+    mask_poll 0XF800010C 0x00000004
+    mask_write 0XF8000108 0x00000010 0x00000000
+    mwr -force 0XF8000004 0x0000767B
+}
+proc ps7_clock_init_data_3_0 {} {
+    mwr -force 0XF8000008 0x0000DF0D
+    mask_write 0XF8000128 0x03F03F01 0x00700F01
+    mask_write 0XF8000138 0x00000011 0x00000001
+    mask_write 0XF8000140 0x03F03F71 0x00100801
+    mask_write 0XF800014C 0x00003F31 0x00000501
+    mask_write 0XF8000150 0x00003F33 0x00001401
+    mask_write 0XF8000154 0x00003F33 0x00001402
+    mask_write 0XF8000168 0x00003F31 0x00000501
+    mask_write 0XF8000170 0x03F03F30 0x00200500
+    mask_write 0XF80001C4 0x00000001 0x00000001
+    mask_write 0XF800012C 0x01FFCCCD 0x01EC044D
+    mwr -force 0XF8000004 0x0000767B
+}
+proc ps7_ddr_init_data_3_0 {} {
+    mask_write 0XF8006000 0x0001FFFF 0x00000080
+    mask_write 0XF8006004 0x0007FFFF 0x00001081
+    mask_write 0XF8006008 0x03FFFFFF 0x03C0780F
+    mask_write 0XF800600C 0x03FFFFFF 0x02001001
+    mask_write 0XF8006010 0x03FFFFFF 0x00014001
+    mask_write 0XF8006014 0x001FFFFF 0x0004159B
+    mask_write 0XF8006018 0xF7FFFFFF 0x452460D2
+    mask_write 0XF800601C 0xFFFFFFFF 0x720238E5
+    mask_write 0XF8006020 0x7FDFFFFC 0x270872D0
+    mask_write 0XF8006024 0x0FFFFFC3 0x00000000
+    mask_write 0XF8006028 0x00003FFF 0x00002007
+    mask_write 0XF800602C 0xFFFFFFFF 0x00000008
+    mask_write 0XF8006030 0xFFFFFFFF 0x00040930
+    mask_write 0XF8006034 0x13FF3FFF 0x000116D4
+    mask_write 0XF8006038 0x00000003 0x00000000
+    mask_write 0XF800603C 0x000FFFFF 0x00000777
+    mask_write 0XF8006040 0xFFFFFFFF 0xFFF00000
+    mask_write 0XF8006044 0x0FFFFFFF 0x0FF66666
+    mask_write 0XF8006048 0x0003F03F 0x0003C008
+    mask_write 0XF8006050 0xFF0F8FFF 0x77010800
+    mask_write 0XF8006058 0x00010000 0x00000000
+    mask_write 0XF800605C 0x0000FFFF 0x00005003
+    mask_write 0XF8006060 0x000017FF 0x0000003E
+    mask_write 0XF8006064 0x00021FE0 0x00020000
+    mask_write 0XF8006068 0x03FFFFFF 0x00284141
+    mask_write 0XF800606C 0x0000FFFF 0x00001610
+    mask_write 0XF8006078 0x03FFFFFF 0x00466111
+    mask_write 0XF800607C 0x000FFFFF 0x00032222
+    mask_write 0XF80060A4 0xFFFFFFFF 0x10200802
+    mask_write 0XF80060A8 0x0FFFFFFF 0x0690CB73
+    mask_write 0XF80060AC 0x000001FF 0x000001FE
+    mask_write 0XF80060B0 0x1FFFFFFF 0x1CFFFFFF
+    mask_write 0XF80060B4 0x00000200 0x00000200
+    mask_write 0XF80060B8 0x01FFFFFF 0x00200066
+    mask_write 0XF80060C4 0x00000003 0x00000000
+    mask_write 0XF80060C8 0x000000FF 0x00000000
+    mask_write 0XF80060DC 0x00000001 0x00000000
+    mask_write 0XF80060F0 0x0000FFFF 0x00000000
+    mask_write 0XF80060F4 0x0000000F 0x00000008
+    mask_write 0XF8006114 0x000000FF 0x00000000
+    mask_write 0XF8006118 0x7FFFFFCF 0x40000001
+    mask_write 0XF800611C 0x7FFFFFCF 0x40000001
+    mask_write 0XF8006120 0x7FFFFFCF 0x40000001
+    mask_write 0XF8006124 0x7FFFFFCF 0x40000001
+    mask_write 0XF800612C 0x000FFFFF 0x00033C03
+    mask_write 0XF8006130 0x000FFFFF 0x00034003
+    mask_write 0XF8006134 0x000FFFFF 0x0002F400
+    mask_write 0XF8006138 0x000FFFFF 0x00030400
+    mask_write 0XF8006140 0x000FFFFF 0x00000035
+    mask_write 0XF8006144 0x000FFFFF 0x00000035
+    mask_write 0XF8006148 0x000FFFFF 0x00000035
+    mask_write 0XF800614C 0x000FFFFF 0x00000035
+    mask_write 0XF8006154 0x000FFFFF 0x00000083
+    mask_write 0XF8006158 0x000FFFFF 0x00000083
+    mask_write 0XF800615C 0x000FFFFF 0x00000080
+    mask_write 0XF8006160 0x000FFFFF 0x00000080
+    mask_write 0XF8006168 0x001FFFFF 0x00000124
+    mask_write 0XF800616C 0x001FFFFF 0x00000125
+    mask_write 0XF8006170 0x001FFFFF 0x00000112
+    mask_write 0XF8006174 0x001FFFFF 0x00000116
+    mask_write 0XF800617C 0x000FFFFF 0x000000C3
+    mask_write 0XF8006180 0x000FFFFF 0x000000C3
+    mask_write 0XF8006184 0x000FFFFF 0x000000C0
+    mask_write 0XF8006188 0x000FFFFF 0x000000C0
+    mask_write 0XF8006190 0x6FFFFEFE 0x00040080
+    mask_write 0XF8006194 0x000FFFFF 0x0001FC82
+    mask_write 0XF8006204 0xFFFFFFFF 0x00000000
+    mask_write 0XF8006208 0x000703FF 0x000003FF
+    mask_write 0XF800620C 0x000703FF 0x000003FF
+    mask_write 0XF8006210 0x000703FF 0x000003FF
+    mask_write 0XF8006214 0x000703FF 0x000003FF
+    mask_write 0XF8006218 0x000F03FF 0x000003FF
+    mask_write 0XF800621C 0x000F03FF 0x000003FF
+    mask_write 0XF8006220 0x000F03FF 0x000003FF
+    mask_write 0XF8006224 0x000F03FF 0x000003FF
+    mask_write 0XF80062A8 0x00000FF5 0x00000000
+    mask_write 0XF80062AC 0xFFFFFFFF 0x00000000
+    mask_write 0XF80062B0 0x003FFFFF 0x00005125
+    mask_write 0XF80062B4 0x0003FFFF 0x000012A8
+    mask_poll 0XF8000B74 0x00002000
+    mask_write 0XF8006000 0x0001FFFF 0x00000081
+    mask_poll 0XF8006054 0x00000007
+}
+proc ps7_mio_init_data_3_0 {} {
+    mwr -force 0XF8000008 0x0000DF0D
+    mask_write 0XF8000B40 0x00000FFF 0x00000600
+    mask_write 0XF8000B44 0x00000FFF 0x00000600
+    mask_write 0XF8000B48 0x00000FFF 0x00000672
+    mask_write 0XF8000B4C 0x00000FFF 0x00000672
+    mask_write 0XF8000B50 0x00000FFF 0x00000674
+    mask_write 0XF8000B54 0x00000FFF 0x00000674
+    mask_write 0XF8000B58 0x00000FFF 0x00000600
+    mask_write 0XF8000B5C 0xFFFFFFFF 0x0018C61C
+    mask_write 0XF8000B60 0xFFFFFFFF 0x00F9861C
+    mask_write 0XF8000B64 0xFFFFFFFF 0x00F9861C
+    mask_write 0XF8000B68 0xFFFFFFFF 0x00F9861C
+    mask_write 0XF8000B6C 0x00007FFF 0x00000209
+    mask_write 0XF8000B70 0x00000001 0x00000001
+    mask_write 0XF8000B70 0x00000021 0x00000020
+    mask_write 0XF8000B70 0x07FEFFFF 0x00000823
+    mask_write 0XF8000700 0x00003FFF 0x00000600
+    mask_write 0XF8000704 0x00003FFF 0x00000702
+    mask_write 0XF8000708 0x00003FFF 0x00000702
+    mask_write 0XF800070C 0x00003FFF 0x00000702
+    mask_write 0XF8000710 0x00003FFF 0x00000702
+    mask_write 0XF8000714 0x00003FFF 0x00000702
+    mask_write 0XF8000718 0x00003FFF 0x00000702
+    mask_write 0XF800071C 0x00003FFF 0x00000600
+    mask_write 0XF8000720 0x00003FFF 0x00000700
+    mask_write 0XF8000724 0x00003FFF 0x00000600
+    mask_write 0XF8000728 0x00003FFF 0x00000600
+    mask_write 0XF800072C 0x00003FFF 0x00000600
+    mask_write 0XF8000730 0x00003FFF 0x00000600
+    mask_write 0XF8000734 0x00003FFF 0x00000600
+    mask_write 0XF8000738 0x00003FFF 0x00000600
+    mask_write 0XF800073C 0x00003FFF 0x00000600
+    mask_write 0XF8000740 0x00003FFF 0x00000302
+    mask_write 0XF8000744 0x00003FFF 0x00000302
+    mask_write 0XF8000748 0x00003FFF 0x00000302
+    mask_write 0XF800074C 0x00003FFF 0x00000302
+    mask_write 0XF8000750 0x00003FFF 0x00000302
+    mask_write 0XF8000754 0x00003FFF 0x00000302
+    mask_write 0XF8000758 0x00003FFF 0x00000303
+    mask_write 0XF800075C 0x00003FFF 0x00000303
+    mask_write 0XF8000760 0x00003FFF 0x00000303
+    mask_write 0XF8000764 0x00003FFF 0x00000303
+    mask_write 0XF8000768 0x00003FFF 0x00000303
+    mask_write 0XF800076C 0x00003FFF 0x00000303
+    mask_write 0XF8000770 0x00003FFF 0x00000304
+    mask_write 0XF8000774 0x00003FFF 0x00000305
+    mask_write 0XF8000778 0x00003FFF 0x00000304
+    mask_write 0XF800077C 0x00003FFF 0x00000305
+    mask_write 0XF8000780 0x00003FFF 0x00000304
+    mask_write 0XF8000784 0x00003FFF 0x00000304
+    mask_write 0XF8000788 0x00003FFF 0x00000304
+    mask_write 0XF800078C 0x00003FFF 0x00000304
+    mask_write 0XF8000790 0x00003FFF 0x00000305
+    mask_write 0XF8000794 0x00003FFF 0x00000304
+    mask_write 0XF8000798 0x00003FFF 0x00000304
+    mask_write 0XF800079C 0x00003FFF 0x00000304
+    mask_write 0XF80007A0 0x00003FFF 0x00000380
+    mask_write 0XF80007A4 0x00003FFF 0x00000380
+    mask_write 0XF80007A8 0x00003FFF 0x00000380
+    mask_write 0XF80007AC 0x00003FFF 0x00000380
+    mask_write 0XF80007B0 0x00003FFF 0x00000380
+    mask_write 0XF80007B4 0x00003FFF 0x00000380
+    mask_write 0XF80007B8 0x00003F01 0x00000201
+    mask_write 0XF80007BC 0x00003F01 0x00000201
+    mask_write 0XF80007C0 0x00003FFF 0x000002E0
+    mask_write 0XF80007C4 0x00003FFF 0x000002E1
+    mask_write 0XF80007C8 0x00003FFF 0x00000200
+    mask_write 0XF80007CC 0x00003FFF 0x00000200
+    mask_write 0XF80007D0 0x00003FFF 0x00000280
+    mask_write 0XF80007D4 0x00003FFF 0x00000280
+    mask_write 0XF8000830 0x003F003F 0x002F002E
+    mwr -force 0XF8000004 0x0000767B
+}
+proc ps7_peripherals_init_data_3_0 {} {
+    mwr -force 0XF8000008 0x0000DF0D
+    mask_write 0XF8000B48 0x00000180 0x00000180
+    mask_write 0XF8000B4C 0x00000180 0x00000180
+    mask_write 0XF8000B50 0x00000180 0x00000180
+    mask_write 0XF8000B54 0x00000180 0x00000180
+    mwr -force 0XF8000004 0x0000767B
+    mask_write 0XE0001034 0x000000FF 0x00000006
+    mask_write 0XE0001018 0x0000FFFF 0x0000003E
+    mask_write 0XE0001000 0x000001FF 0x00000017
+    mask_write 0XE0001004 0x000003FF 0x00000020
+    mask_write 0XE000D000 0x00080000 0x00080000
+    mask_write 0XF8007000 0x20000000 0x00000000
+}
+proc ps7_post_config_3_0 {} {
+    mwr -force 0XF8000008 0x0000DF0D
+    mask_write 0XF8000900 0x0000000F 0x0000000F
+    mask_write 0XF8000240 0xFFFFFFFF 0x00000000
+    mwr -force 0XF8000004 0x0000767B
+}
+proc ps7_debug_3_0 {} {
+    mwr -force 0XF8898FB0 0xC5ACCE55
+    mwr -force 0XF8899FB0 0xC5ACCE55
+    mwr -force 0XF8809FB0 0xC5ACCE55
+}
+proc ps7_pll_init_data_2_0 {} {
+    mwr -force 0XF8000008 0x0000DF0D
+    mask_write 0XF8000110 0x003FFFF0 0x000FA220
+    mask_write 0XF8000100 0x0007F000 0x00028000
+    mask_write 0XF8000100 0x00000010 0x00000010
+    mask_write 0XF8000100 0x00000001 0x00000001
+    mask_write 0XF8000100 0x00000001 0x00000000
+    mask_poll 0XF800010C 0x00000001
+    mask_write 0XF8000100 0x00000010 0x00000000
+    mask_write 0XF8000120 0x1F003F30 0x1F000200
+    mask_write 0XF8000114 0x003FFFF0 0x0012C220
+    mask_write 0XF8000104 0x0007F000 0x00020000
+    mask_write 0XF8000104 0x00000010 0x00000010
+    mask_write 0XF8000104 0x00000001 0x00000001
+    mask_write 0XF8000104 0x00000001 0x00000000
+    mask_poll 0XF800010C 0x00000002
+    mask_write 0XF8000104 0x00000010 0x00000000
+    mask_write 0XF8000124 0xFFF00003 0x0C200003
+    mask_write 0XF8000118 0x003FFFF0 0x001452C0
+    mask_write 0XF8000108 0x0007F000 0x0001E000
+    mask_write 0XF8000108 0x00000010 0x00000010
+    mask_write 0XF8000108 0x00000001 0x00000001
+    mask_write 0XF8000108 0x00000001 0x00000000
+    mask_poll 0XF800010C 0x00000004
+    mask_write 0XF8000108 0x00000010 0x00000000
+    mwr -force 0XF8000004 0x0000767B
+}
+proc ps7_clock_init_data_2_0 {} {
+    mwr -force 0XF8000008 0x0000DF0D
+    mask_write 0XF8000128 0x03F03F01 0x00700F01
+    mask_write 0XF8000138 0x00000011 0x00000001
+    mask_write 0XF8000140 0x03F03F71 0x00100801
+    mask_write 0XF800014C 0x00003F31 0x00000501
+    mask_write 0XF8000150 0x00003F33 0x00001401
+    mask_write 0XF8000154 0x00003F33 0x00001402
+    mask_write 0XF8000168 0x00003F31 0x00000501
+    mask_write 0XF8000170 0x03F03F30 0x00200500
+    mask_write 0XF80001C4 0x00000001 0x00000001
+    mask_write 0XF800012C 0x01FFCCCD 0x01EC044D
+    mwr -force 0XF8000004 0x0000767B
+}
+proc ps7_ddr_init_data_2_0 {} {
+    mask_write 0XF8006000 0x0001FFFF 0x00000080
+    mask_write 0XF8006004 0x1FFFFFFF 0x00081081
+    mask_write 0XF8006008 0x03FFFFFF 0x03C0780F
+    mask_write 0XF800600C 0x03FFFFFF 0x02001001
+    mask_write 0XF8006010 0x03FFFFFF 0x00014001
+    mask_write 0XF8006014 0x001FFFFF 0x0004159B
+    mask_write 0XF8006018 0xF7FFFFFF 0x452460D2
+    mask_write 0XF800601C 0xFFFFFFFF 0x720238E5
+    mask_write 0XF8006020 0xFFFFFFFC 0x272872D0
+    mask_write 0XF8006024 0x0FFFFFFF 0x0000003C
+    mask_write 0XF8006028 0x00003FFF 0x00002007
+    mask_write 0XF800602C 0xFFFFFFFF 0x00000008
+    mask_write 0XF8006030 0xFFFFFFFF 0x00040930
+    mask_write 0XF8006034 0x13FF3FFF 0x000116D4
+    mask_write 0XF8006038 0x00001FC3 0x00000000
+    mask_write 0XF800603C 0x000FFFFF 0x00000777
+    mask_write 0XF8006040 0xFFFFFFFF 0xFFF00000
+    mask_write 0XF8006044 0x0FFFFFFF 0x0FF66666
+    mask_write 0XF8006048 0x3FFFFFFF 0x0003C248
+    mask_write 0XF8006050 0xFF0F8FFF 0x77010800
+    mask_write 0XF8006058 0x0001FFFF 0x00000101
+    mask_write 0XF800605C 0x0000FFFF 0x00005003
+    mask_write 0XF8006060 0x000017FF 0x0000003E
+    mask_write 0XF8006064 0x00021FE0 0x00020000
+    mask_write 0XF8006068 0x03FFFFFF 0x00284141
+    mask_write 0XF800606C 0x0000FFFF 0x00001610
+    mask_write 0XF8006078 0x03FFFFFF 0x00466111
+    mask_write 0XF800607C 0x000FFFFF 0x00032222
+    mask_write 0XF80060A0 0x00FFFFFF 0x00008000
+    mask_write 0XF80060A4 0xFFFFFFFF 0x10200802
+    mask_write 0XF80060A8 0x0FFFFFFF 0x0690CB73
+    mask_write 0XF80060AC 0x000001FF 0x000001FE
+    mask_write 0XF80060B0 0x1FFFFFFF 0x1CFFFFFF
+    mask_write 0XF80060B4 0x000007FF 0x00000200
+    mask_write 0XF80060B8 0x01FFFFFF 0x00200066
+    mask_write 0XF80060C4 0x00000003 0x00000000
+    mask_write 0XF80060C8 0x000000FF 0x00000000
+    mask_write 0XF80060DC 0x00000001 0x00000000
+    mask_write 0XF80060F0 0x0000FFFF 0x00000000
+    mask_write 0XF80060F4 0x0000000F 0x00000008
+    mask_write 0XF8006114 0x000000FF 0x00000000
+    mask_write 0XF8006118 0x7FFFFFFF 0x40000001
+    mask_write 0XF800611C 0x7FFFFFFF 0x40000001
+    mask_write 0XF8006120 0x7FFFFFFF 0x40000001
+    mask_write 0XF8006124 0x7FFFFFFF 0x40000001
+    mask_write 0XF800612C 0x000FFFFF 0x00033C03
+    mask_write 0XF8006130 0x000FFFFF 0x00034003
+    mask_write 0XF8006134 0x000FFFFF 0x0002F400
+    mask_write 0XF8006138 0x000FFFFF 0x00030400
+    mask_write 0XF8006140 0x000FFFFF 0x00000035
+    mask_write 0XF8006144 0x000FFFFF 0x00000035
+    mask_write 0XF8006148 0x000FFFFF 0x00000035
+    mask_write 0XF800614C 0x000FFFFF 0x00000035
+    mask_write 0XF8006154 0x000FFFFF 0x00000083
+    mask_write 0XF8006158 0x000FFFFF 0x00000083
+    mask_write 0XF800615C 0x000FFFFF 0x00000080
+    mask_write 0XF8006160 0x000FFFFF 0x00000080
+    mask_write 0XF8006168 0x001FFFFF 0x00000124
+    mask_write 0XF800616C 0x001FFFFF 0x00000125
+    mask_write 0XF8006170 0x001FFFFF 0x00000112
+    mask_write 0XF8006174 0x001FFFFF 0x00000116
+    mask_write 0XF800617C 0x000FFFFF 0x000000C3
+    mask_write 0XF8006180 0x000FFFFF 0x000000C3
+    mask_write 0XF8006184 0x000FFFFF 0x000000C0
+    mask_write 0XF8006188 0x000FFFFF 0x000000C0
+    mask_write 0XF8006190 0xFFFFFFFF 0x10040080
+    mask_write 0XF8006194 0x000FFFFF 0x0001FC82
+    mask_write 0XF8006204 0xFFFFFFFF 0x00000000
+    mask_write 0XF8006208 0x000F03FF 0x000803FF
+    mask_write 0XF800620C 0x000F03FF 0x000803FF
+    mask_write 0XF8006210 0x000F03FF 0x000803FF
+    mask_write 0XF8006214 0x000F03FF 0x000803FF
+    mask_write 0XF8006218 0x000F03FF 0x000003FF
+    mask_write 0XF800621C 0x000F03FF 0x000003FF
+    mask_write 0XF8006220 0x000F03FF 0x000003FF
+    mask_write 0XF8006224 0x000F03FF 0x000003FF
+    mask_write 0XF80062A8 0x00000FF7 0x00000000
+    mask_write 0XF80062AC 0xFFFFFFFF 0x00000000
+    mask_write 0XF80062B0 0x003FFFFF 0x00005125
+    mask_write 0XF80062B4 0x0003FFFF 0x000012A8
+    mask_poll 0XF8000B74 0x00002000
+    mask_write 0XF8006000 0x0001FFFF 0x00000081
+    mask_poll 0XF8006054 0x00000007
+}
+proc ps7_mio_init_data_2_0 {} {
+    mwr -force 0XF8000008 0x0000DF0D
+    mask_write 0XF8000B40 0x00000FFF 0x00000600
+    mask_write 0XF8000B44 0x00000FFF 0x00000600
+    mask_write 0XF8000B48 0x00000FFF 0x00000672
+    mask_write 0XF8000B4C 0x00000FFF 0x00000672
+    mask_write 0XF8000B50 0x00000FFF 0x00000674
+    mask_write 0XF8000B54 0x00000FFF 0x00000674
+    mask_write 0XF8000B58 0x00000FFF 0x00000600
+    mask_write 0XF8000B5C 0xFFFFFFFF 0x0018C61C
+    mask_write 0XF8000B60 0xFFFFFFFF 0x00F9861C
+    mask_write 0XF8000B64 0xFFFFFFFF 0x00F9861C
+    mask_write 0XF8000B68 0xFFFFFFFF 0x00F9861C
+    mask_write 0XF8000B6C 0x00007FFF 0x00000209
+    mask_write 0XF8000B70 0x00000021 0x00000021
+    mask_write 0XF8000B70 0x00000021 0x00000020
+    mask_write 0XF8000B70 0x07FFFFFF 0x00000823
+    mask_write 0XF8000700 0x00003FFF 0x00000600
+    mask_write 0XF8000704 0x00003FFF 0x00000702
+    mask_write 0XF8000708 0x00003FFF 0x00000702
+    mask_write 0XF800070C 0x00003FFF 0x00000702
+    mask_write 0XF8000710 0x00003FFF 0x00000702
+    mask_write 0XF8000714 0x00003FFF 0x00000702
+    mask_write 0XF8000718 0x00003FFF 0x00000702
+    mask_write 0XF800071C 0x00003FFF 0x00000600
+    mask_write 0XF8000720 0x00003FFF 0x00000700
+    mask_write 0XF8000724 0x00003FFF 0x00000600
+    mask_write 0XF8000728 0x00003FFF 0x00000600
+    mask_write 0XF800072C 0x00003FFF 0x00000600
+    mask_write 0XF8000730 0x00003FFF 0x00000600
+    mask_write 0XF8000734 0x00003FFF 0x00000600
+    mask_write 0XF8000738 0x00003FFF 0x00000600
+    mask_write 0XF800073C 0x00003FFF 0x00000600
+    mask_write 0XF8000740 0x00003FFF 0x00000302
+    mask_write 0XF8000744 0x00003FFF 0x00000302
+    mask_write 0XF8000748 0x00003FFF 0x00000302
+    mask_write 0XF800074C 0x00003FFF 0x00000302
+    mask_write 0XF8000750 0x00003FFF 0x00000302
+    mask_write 0XF8000754 0x00003FFF 0x00000302
+    mask_write 0XF8000758 0x00003FFF 0x00000303
+    mask_write 0XF800075C 0x00003FFF 0x00000303
+    mask_write 0XF8000760 0x00003FFF 0x00000303
+    mask_write 0XF8000764 0x00003FFF 0x00000303
+    mask_write 0XF8000768 0x00003FFF 0x00000303
+    mask_write 0XF800076C 0x00003FFF 0x00000303
+    mask_write 0XF8000770 0x00003FFF 0x00000304
+    mask_write 0XF8000774 0x00003FFF 0x00000305
+    mask_write 0XF8000778 0x00003FFF 0x00000304
+    mask_write 0XF800077C 0x00003FFF 0x00000305
+    mask_write 0XF8000780 0x00003FFF 0x00000304
+    mask_write 0XF8000784 0x00003FFF 0x00000304
+    mask_write 0XF8000788 0x00003FFF 0x00000304
+    mask_write 0XF800078C 0x00003FFF 0x00000304
+    mask_write 0XF8000790 0x00003FFF 0x00000305
+    mask_write 0XF8000794 0x00003FFF 0x00000304
+    mask_write 0XF8000798 0x00003FFF 0x00000304
+    mask_write 0XF800079C 0x00003FFF 0x00000304
+    mask_write 0XF80007A0 0x00003FFF 0x00000380
+    mask_write 0XF80007A4 0x00003FFF 0x00000380
+    mask_write 0XF80007A8 0x00003FFF 0x00000380
+    mask_write 0XF80007AC 0x00003FFF 0x00000380
+    mask_write 0XF80007B0 0x00003FFF 0x00000380
+    mask_write 0XF80007B4 0x00003FFF 0x00000380
+    mask_write 0XF80007B8 0x00003F01 0x00000201
+    mask_write 0XF80007BC 0x00003F01 0x00000201
+    mask_write 0XF80007C0 0x00003FFF 0x000002E0
+    mask_write 0XF80007C4 0x00003FFF 0x000002E1
+    mask_write 0XF80007C8 0x00003FFF 0x00000200
+    mask_write 0XF80007CC 0x00003FFF 0x00000200
+    mask_write 0XF80007D0 0x00003FFF 0x00000280
+    mask_write 0XF80007D4 0x00003FFF 0x00000280
+    mask_write 0XF8000830 0x003F003F 0x002F002E
+    mwr -force 0XF8000004 0x0000767B
+}
+proc ps7_peripherals_init_data_2_0 {} {
+    mwr -force 0XF8000008 0x0000DF0D
+    mask_write 0XF8000B48 0x00000180 0x00000180
+    mask_write 0XF8000B4C 0x00000180 0x00000180
+    mask_write 0XF8000B50 0x00000180 0x00000180
+    mask_write 0XF8000B54 0x00000180 0x00000180
+    mwr -force 0XF8000004 0x0000767B
+    mask_write 0XE0001034 0x000000FF 0x00000006
+    mask_write 0XE0001018 0x0000FFFF 0x0000003E
+    mask_write 0XE0001000 0x000001FF 0x00000017
+    mask_write 0XE0001004 0x00000FFF 0x00000020
+    mask_write 0XE000D000 0x00080000 0x00080000
+    mask_write 0XF8007000 0x20000000 0x00000000
+}
+proc ps7_post_config_2_0 {} {
+    mwr -force 0XF8000008 0x0000DF0D
+    mask_write 0XF8000900 0x0000000F 0x0000000F
+    mask_write 0XF8000240 0xFFFFFFFF 0x00000000
+    mwr -force 0XF8000004 0x0000767B
+}
+proc ps7_debug_2_0 {} {
+    mwr -force 0XF8898FB0 0xC5ACCE55
+    mwr -force 0XF8899FB0 0xC5ACCE55
+    mwr -force 0XF8809FB0 0xC5ACCE55
+}
+proc ps7_pll_init_data_1_0 {} {
+    mwr -force 0XF8000008 0x0000DF0D
+    mask_write 0XF8000110 0x003FFFF0 0x000FA220
+    mask_write 0XF8000100 0x0007F000 0x00028000
+    mask_write 0XF8000100 0x00000010 0x00000010
+    mask_write 0XF8000100 0x00000001 0x00000001
+    mask_write 0XF8000100 0x00000001 0x00000000
+    mask_poll 0XF800010C 0x00000001
+    mask_write 0XF8000100 0x00000010 0x00000000
+    mask_write 0XF8000120 0x1F003F30 0x1F000200
+    mask_write 0XF8000114 0x003FFFF0 0x0012C220
+    mask_write 0XF8000104 0x0007F000 0x00020000
+    mask_write 0XF8000104 0x00000010 0x00000010
+    mask_write 0XF8000104 0x00000001 0x00000001
+    mask_write 0XF8000104 0x00000001 0x00000000
+    mask_poll 0XF800010C 0x00000002
+    mask_write 0XF8000104 0x00000010 0x00000000
+    mask_write 0XF8000124 0xFFF00003 0x0C200003
+    mask_write 0XF8000118 0x003FFFF0 0x001452C0
+    mask_write 0XF8000108 0x0007F000 0x0001E000
+    mask_write 0XF8000108 0x00000010 0x00000010
+    mask_write 0XF8000108 0x00000001 0x00000001
+    mask_write 0XF8000108 0x00000001 0x00000000
+    mask_poll 0XF800010C 0x00000004
+    mask_write 0XF8000108 0x00000010 0x00000000
+    mwr -force 0XF8000004 0x0000767B
+}
+proc ps7_clock_init_data_1_0 {} {
+    mwr -force 0XF8000008 0x0000DF0D
+    mask_write 0XF8000128 0x03F03F01 0x00700F01
+    mask_write 0XF8000138 0x00000011 0x00000001
+    mask_write 0XF8000140 0x03F03F71 0x00100801
+    mask_write 0XF800014C 0x00003F31 0x00000501
+    mask_write 0XF8000150 0x00003F33 0x00001401
+    mask_write 0XF8000154 0x00003F33 0x00001402
+    mask_write 0XF8000168 0x00003F31 0x00000501
+    mask_write 0XF8000170 0x03F03F30 0x00200400
+    mask_write 0XF80001C4 0x00000001 0x00000001
+    mask_write 0XF800012C 0x01FFCCCD 0x01EC044D
+    mwr -force 0XF8000004 0x0000767B
+}
+proc ps7_ddr_init_data_1_0 {} {
+    mask_write 0XF8006000 0x0001FFFF 0x00000080
+    mask_write 0XF8006004 0x1FFFFFFF 0x00081081
+    mask_write 0XF8006008 0x03FFFFFF 0x03C0780F
+    mask_write 0XF800600C 0x03FFFFFF 0x02001001
+    mask_write 0XF8006010 0x03FFFFFF 0x00014001
+    mask_write 0XF8006014 0x001FFFFF 0x0004159B
+    mask_write 0XF8006018 0xF7FFFFFF 0x452460D2
+    mask_write 0XF800601C 0xFFFFFFFF 0x720238E5
+    mask_write 0XF8006020 0xFFFFFFFC 0x272872D0
+    mask_write 0XF8006024 0x0FFFFFFF 0x0000003C
+    mask_write 0XF8006028 0x00003FFF 0x00002007
+    mask_write 0XF800602C 0xFFFFFFFF 0x00000008
+    mask_write 0XF8006030 0xFFFFFFFF 0x00040930
+    mask_write 0XF8006034 0x13FF3FFF 0x000116D4
+    mask_write 0XF8006038 0x00001FC3 0x00000000
+    mask_write 0XF800603C 0x000FFFFF 0x00000777
+    mask_write 0XF8006040 0xFFFFFFFF 0xFFF00000
+    mask_write 0XF8006044 0x0FFFFFFF 0x0FF66666
+    mask_write 0XF8006048 0x3FFFFFFF 0x0003C248
+    mask_write 0XF8006050 0xFF0F8FFF 0x77010800
+    mask_write 0XF8006058 0x0001FFFF 0x00000101
+    mask_write 0XF800605C 0x0000FFFF 0x00005003
+    mask_write 0XF8006060 0x000017FF 0x0000003E
+    mask_write 0XF8006064 0x00021FE0 0x00020000
+    mask_write 0XF8006068 0x03FFFFFF 0x00284141
+    mask_write 0XF800606C 0x0000FFFF 0x00001610
+    mask_write 0XF80060A0 0x00FFFFFF 0x00008000
+    mask_write 0XF80060A4 0xFFFFFFFF 0x10200802
+    mask_write 0XF80060A8 0x0FFFFFFF 0x0690CB73
+    mask_write 0XF80060AC 0x000001FF 0x000001FE
+    mask_write 0XF80060B0 0x1FFFFFFF 0x1CFFFFFF
+    mask_write 0XF80060B4 0x000007FF 0x00000200
+    mask_write 0XF80060B8 0x01FFFFFF 0x00200066
+    mask_write 0XF80060C4 0x00000003 0x00000000
+    mask_write 0XF80060C8 0x000000FF 0x00000000
+    mask_write 0XF80060DC 0x00000001 0x00000000
+    mask_write 0XF80060F0 0x0000FFFF 0x00000000
+    mask_write 0XF80060F4 0x0000000F 0x00000008
+    mask_write 0XF8006114 0x000000FF 0x00000000
+    mask_write 0XF8006118 0x7FFFFFFF 0x40000001
+    mask_write 0XF800611C 0x7FFFFFFF 0x40000001
+    mask_write 0XF8006120 0x7FFFFFFF 0x40000001
+    mask_write 0XF8006124 0x7FFFFFFF 0x40000001
+    mask_write 0XF800612C 0x000FFFFF 0x00033C03
+    mask_write 0XF8006130 0x000FFFFF 0x00034003
+    mask_write 0XF8006134 0x000FFFFF 0x0002F400
+    mask_write 0XF8006138 0x000FFFFF 0x00030400
+    mask_write 0XF8006140 0x000FFFFF 0x00000035
+    mask_write 0XF8006144 0x000FFFFF 0x00000035
+    mask_write 0XF8006148 0x000FFFFF 0x00000035
+    mask_write 0XF800614C 0x000FFFFF 0x00000035
+    mask_write 0XF8006154 0x000FFFFF 0x00000083
+    mask_write 0XF8006158 0x000FFFFF 0x00000083
+    mask_write 0XF800615C 0x000FFFFF 0x00000080
+    mask_write 0XF8006160 0x000FFFFF 0x00000080
+    mask_write 0XF8006168 0x001FFFFF 0x00000124
+    mask_write 0XF800616C 0x001FFFFF 0x00000125
+    mask_write 0XF8006170 0x001FFFFF 0x00000112
+    mask_write 0XF8006174 0x001FFFFF 0x00000116
+    mask_write 0XF800617C 0x000FFFFF 0x000000C3
+    mask_write 0XF8006180 0x000FFFFF 0x000000C3
+    mask_write 0XF8006184 0x000FFFFF 0x000000C0
+    mask_write 0XF8006188 0x000FFFFF 0x000000C0
+    mask_write 0XF8006190 0xFFFFFFFF 0x10040080
+    mask_write 0XF8006194 0x000FFFFF 0x0001FC82
+    mask_write 0XF8006204 0xFFFFFFFF 0x00000000
+    mask_write 0XF8006208 0x000F03FF 0x000803FF
+    mask_write 0XF800620C 0x000F03FF 0x000803FF
+    mask_write 0XF8006210 0x000F03FF 0x000803FF
+    mask_write 0XF8006214 0x000F03FF 0x000803FF
+    mask_write 0XF8006218 0x000F03FF 0x000003FF
+    mask_write 0XF800621C 0x000F03FF 0x000003FF
+    mask_write 0XF8006220 0x000F03FF 0x000003FF
+    mask_write 0XF8006224 0x000F03FF 0x000003FF
+    mask_write 0XF80062A8 0x00000FF7 0x00000000
+    mask_write 0XF80062AC 0xFFFFFFFF 0x00000000
+    mask_write 0XF80062B0 0x003FFFFF 0x00005125
+    mask_write 0XF80062B4 0x0003FFFF 0x000012A8
+    mask_poll 0XF8000B74 0x00002000
+    mask_write 0XF8006000 0x0001FFFF 0x00000081
+    mask_poll 0XF8006054 0x00000007
+}
+proc ps7_mio_init_data_1_0 {} {
+    mwr -force 0XF8000008 0x0000DF0D
+    mask_write 0XF8000B40 0x00000FFF 0x00000600
+    mask_write 0XF8000B44 0x00000FFF 0x00000600
+    mask_write 0XF8000B48 0x00000FFF 0x00000672
+    mask_write 0XF8000B4C 0x00000FFF 0x00000672
+    mask_write 0XF8000B50 0x00000FFF 0x00000674
+    mask_write 0XF8000B54 0x00000FFF 0x00000674
+    mask_write 0XF8000B58 0x00000FFF 0x00000600
+    mask_write 0XF8000B5C 0xFFFFFFFF 0x0018C61C
+    mask_write 0XF8000B60 0xFFFFFFFF 0x00F9861C
+    mask_write 0XF8000B64 0xFFFFFFFF 0x00F9861C
+    mask_write 0XF8000B68 0xFFFFFFFF 0x00F9861C
+    mask_write 0XF8000B6C 0x000073FF 0x00000209
+    mask_write 0XF8000B70 0x00000021 0x00000021
+    mask_write 0XF8000B70 0x00000021 0x00000020
+    mask_write 0XF8000B70 0x07FFFFFF 0x00000823
+    mask_write 0XF8000700 0x00003FFF 0x00000600
+    mask_write 0XF8000704 0x00003FFF 0x00000702
+    mask_write 0XF8000708 0x00003FFF 0x00000702
+    mask_write 0XF800070C 0x00003FFF 0x00000702
+    mask_write 0XF8000710 0x00003FFF 0x00000702
+    mask_write 0XF8000714 0x00003FFF 0x00000702
+    mask_write 0XF8000718 0x00003FFF 0x00000702
+    mask_write 0XF800071C 0x00003FFF 0x00000600
+    mask_write 0XF8000720 0x00003FFF 0x00000700
+    mask_write 0XF8000724 0x00003FFF 0x00000600
+    mask_write 0XF8000728 0x00003FFF 0x00000600
+    mask_write 0XF800072C 0x00003FFF 0x00000600
+    mask_write 0XF8000730 0x00003FFF 0x00000600
+    mask_write 0XF8000734 0x00003FFF 0x00000600
+    mask_write 0XF8000738 0x00003FFF 0x00000600
+    mask_write 0XF800073C 0x00003FFF 0x00000600
+    mask_write 0XF8000740 0x00003FFF 0x00000302
+    mask_write 0XF8000744 0x00003FFF 0x00000302
+    mask_write 0XF8000748 0x00003FFF 0x00000302
+    mask_write 0XF800074C 0x00003FFF 0x00000302
+    mask_write 0XF8000750 0x00003FFF 0x00000302
+    mask_write 0XF8000754 0x00003FFF 0x00000302
+    mask_write 0XF8000758 0x00003FFF 0x00000303
+    mask_write 0XF800075C 0x00003FFF 0x00000303
+    mask_write 0XF8000760 0x00003FFF 0x00000303
+    mask_write 0XF8000764 0x00003FFF 0x00000303
+    mask_write 0XF8000768 0x00003FFF 0x00000303
+    mask_write 0XF800076C 0x00003FFF 0x00000303
+    mask_write 0XF8000770 0x00003FFF 0x00000304
+    mask_write 0XF8000774 0x00003FFF 0x00000305
+    mask_write 0XF8000778 0x00003FFF 0x00000304
+    mask_write 0XF800077C 0x00003FFF 0x00000305
+    mask_write 0XF8000780 0x00003FFF 0x00000304
+    mask_write 0XF8000784 0x00003FFF 0x00000304
+    mask_write 0XF8000788 0x00003FFF 0x00000304
+    mask_write 0XF800078C 0x00003FFF 0x00000304
+    mask_write 0XF8000790 0x00003FFF 0x00000305
+    mask_write 0XF8000794 0x00003FFF 0x00000304
+    mask_write 0XF8000798 0x00003FFF 0x00000304
+    mask_write 0XF800079C 0x00003FFF 0x00000304
+    mask_write 0XF80007A0 0x00003FFF 0x00000380
+    mask_write 0XF80007A4 0x00003FFF 0x00000380
+    mask_write 0XF80007A8 0x00003FFF 0x00000380
+    mask_write 0XF80007AC 0x00003FFF 0x00000380
+    mask_write 0XF80007B0 0x00003FFF 0x00000380
+    mask_write 0XF80007B4 0x00003FFF 0x00000380
+    mask_write 0XF80007B8 0x00003F01 0x00000201
+    mask_write 0XF80007BC 0x00003F01 0x00000201
+    mask_write 0XF80007C0 0x00003FFF 0x000002E0
+    mask_write 0XF80007C4 0x00003FFF 0x000002E1
+    mask_write 0XF80007C8 0x00003FFF 0x00000200
+    mask_write 0XF80007CC 0x00003FFF 0x00000200
+    mask_write 0XF80007D0 0x00003FFF 0x00000280
+    mask_write 0XF80007D4 0x00003FFF 0x00000280
+    mask_write 0XF8000830 0x003F003F 0x002F002E
+    mwr -force 0XF8000004 0x0000767B
+}
+proc ps7_peripherals_init_data_1_0 {} {
+    mwr -force 0XF8000008 0x0000DF0D
+    mask_write 0XF8000B48 0x00000180 0x00000180
+    mask_write 0XF8000B4C 0x00000180 0x00000180
+    mask_write 0XF8000B50 0x00000180 0x00000180
+    mask_write 0XF8000B54 0x00000180 0x00000180
+    mwr -force 0XF8000004 0x0000767B
+    mask_write 0XE0001034 0x000000FF 0x00000006
+    mask_write 0XE0001018 0x0000FFFF 0x0000003E
+    mask_write 0XE0001000 0x000001FF 0x00000017
+    mask_write 0XE0001004 0x00000FFF 0x00000020
+    mask_write 0XE000D000 0x00080000 0x00080000
+    mask_write 0XF8007000 0x20000000 0x00000000
+}
+proc ps7_post_config_1_0 {} {
+    mwr -force 0XF8000008 0x0000DF0D
+    mask_write 0XF8000900 0x0000000F 0x0000000F
+    mask_write 0XF8000240 0xFFFFFFFF 0x00000000
+    mwr -force 0XF8000004 0x0000767B
+}
+proc ps7_debug_1_0 {} {
+    mwr -force 0XF8898FB0 0xC5ACCE55
+    mwr -force 0XF8899FB0 0xC5ACCE55
+    mwr -force 0XF8809FB0 0xC5ACCE55
+}
+set PCW_SILICON_VER_1_0 "0x0"
+set PCW_SILICON_VER_2_0 "0x1"
+set PCW_SILICON_VER_3_0 "0x2"
+set APU_FREQ  666666667
+
+
+
+proc mask_poll { addr mask } {
+    set count 1
+    set curval "0x[string range [mrd $addr] end-8 end]"
+    set maskedval [expr {$curval & $mask}]
+    while { $maskedval == 0 } {
+        set curval "0x[string range [mrd $addr] end-8 end]"
+        set maskedval [expr {$curval & $mask}]
+        set count [ expr { $count + 1 } ]
+        if { $count == 100000000 } {
+          puts "Timeout Reached. Mask poll failed at ADDRESS: $addr MASK: $mask"
+          break
+        }
+    }
+}
+
+
+
+proc mask_delay { addr val } {
+    set delay  [ get_number_of_cycles_for_delay $val ]
+    perf_reset_and_start_timer
+    set curval "0x[string range [mrd $addr] end-8 end]"
+    set maskedval [expr {$curval < $delay}]
+    while { $maskedval == 1 } {
+        set curval "0x[string range [mrd $addr] end-8 end]"
+        set maskedval [expr {$curval < $delay}]
+    }
+    perf_reset_clock 
+}
+
+proc ps_version { } {
+    set si_ver "0x[string range [mrd 0xF8007080] end-8 end]"
+    set mask_sil_ver "0x[expr {$si_ver >> 28}]"
+    return $mask_sil_ver;
+}
+
+proc ps7_post_config {} {
+
+        ps7_post_config_1_0   
+
+}
+
+proc ps7_debug {} {
+        ps7_debug_1_0   
+
+}
+proc ps7_init {} {
+
+            ps7_mio_init_data_1_0
+            ps7_pll_init_data_1_0
+            ps7_clock_init_data_1_0
+            ps7_ddr_init_data_1_0
+            ps7_peripherals_init_data_1_0
+}
+
+
+# For delay calculation using global timer 
+
+# start timer 
+ proc perf_start_clock { } {
+
+    #writing SCU_GLOBAL_TIMER_CONTROL register
+
+    mask_write 0xF8F00208 0x00000109 0x00000009
+}
+
+# stop timer and reset timer count regs 
+ proc perf_reset_clock { } {
+	perf_disable_clock
+    mask_write 0xF8F00200 0xFFFFFFFF 0x00000000
+    mask_write 0xF8F00204 0xFFFFFFFF 0x00000000
+}
+
+# Compute mask for given delay in miliseconds
+proc get_number_of_cycles_for_delay { delay } {
+
+  # GTC is always clocked at 1/2 of the CPU frequency (CPU_3x2x)
+  variable APU_FREQ
+  return [ expr ($delay * $APU_FREQ /(2 * 1000))]
+}
+
+
+# stop timer 
+proc perf_disable_clock {} {
+    mask_write 0xF8F00208 0xFFFFFFFF 0x00000000 
+}
+
+proc perf_reset_and_start_timer {} {
+  	    perf_reset_clock 
+	    perf_start_clock 
+}
+
+

openocd/xilinx-tcl.cfg

@@ -0,0 +1,61 @@
+#
+# TCL to allow the Xilinx PS7 Init TCL code to run in OpenOCD.
+#
+
+proc mrd { args } {
+    if {[llength $args] == 0} {
+        echo "mrd address \[count \[w|h|b\]\]"
+        echo "    Read <count> memory locations starting at <address>.  Defaults to one word."
+        return
+    }
+    set addr [lindex $args 0]
+    set count  1
+    set bits  32
+    if {[llength $args] > 1} {
+        set count [lindex $args 1]
+        if {[llength $args] > 2} {
+            switch [lindex $args 2] {
+                w       { set bits 32 }
+                h       { set bits 16 }
+                b       { set bits  8 }
+                default { set bits 32 }
+            }
+        }
+    }
+    mem2array x $bits $addr $count
+    set nibbles [expr {$bits / 4}]
+    set bytes   [expr {$bits / 8}]
+    set result  {}
+    foreach {idx elmt} $x {
+        append result [format "%08x:   %0*x\n" [expr {$addr + $idx * $bytes}] $nibbles $elmt]
+    }
+    return $result
+}
+
+proc mwr { args } {
+  set addr [lindex $args 1]
+  set data [lindex $args 2]
+  mww $addr $data
+}
+
+proc mask_write { addr mask value } {
+    set curval "0x[string range [mrd $addr] end-8 end]"
+    set maskedval [expr {$curval & ~$mask}]
+    #echo "curval = [format 0x%08x $curval] maskedval = [format 0x%08x $maskedval]"
+    set writeval(0) [expr {$maskedval | $value}]
+    #echo " $addr <= [format 0x%08x $writeval(0)] ([format 0x%08x $curval]: [format 0x%08x $mask]/[format 0x%08x $value])"
+    array2mem writeval 32 $addr 1
+}
+
+proc xilinx_ps7_init { } {
+   poll off
+   reset init
+   reset halt
+   targets zynq.cpu.0
+   sleep 100
+   halt
+   ps7_debug
+   ps7_init
+   ps7_post_config
+   poll on
+}

openocd/zc706.cfg

@@ -0,0 +1,43 @@
+source [find interface/ftdi/olimex-arm-usb-tiny-h.cfg]
+source [find xilinx-tcl.cfg]
+adapter_khz 1000
+
+set PL_TAPID 0x23731093
+set SMP 1
+
+source ./zynq-7000.cfg
+source ./xilinx-tcl.cfg
+source ./ps7_init.tcl
+
+reset_config srst_only srst_open_drain
+adapter_nsrst_assert_width 250
+adapter_nsrst_delay 400
+
+set XC7_JSHUTDOWN 0x0d
+set XC7_JPROGRAM 0x0b
+set XC7_JSTART 0x0c
+set XC7_BYPASS 0x3f
+
+proc xc7_program {tap} {
+    global XC7_JSHUTDOWN XC7_JPROGRAM XC7_JSTART XC7_BYPASS
+    irscan $tap $XC7_JSHUTDOWN
+    irscan $tap $XC7_JPROGRAM
+    runtest 60000
+    #JSTART prevents this from working...
+    #irscan $tap $XC7_JSTART
+    runtest 2000
+    irscan $tap $XC7_BYPASS
+    runtest 2000
+}
+
+pld device virtex2 zynq.tap 1
+init
+xc7_program zynq.tap
+
+xilinx_ps7_init
+
+# Disable MMU
+targets $_TARGETNAME_1
+arm mcr 15 0 1 0 0 [expr [arm mrc 15 0 1 0 0] & ~0xd]
+targets $_TARGETNAME_0
+arm mcr 15 0 1 0 0 [expr [arm mrc 15 0 1 0 0] & ~0xd]

openocd/zynq-7000.cfg

@@ -0,0 +1,211 @@
+#
+# Xilinx Zynq 7000 SoC
+#
+#  Chris Johns <chrisj@rtems.org>
+#
+# Setup
+# -----
+#
+# Create a user configuration following the "Configuration Basics" in the user
+# documentation. In the file have:
+#
+#    source [find interface/ftdi/flyswatter2.cfg]
+#    source [find board/zynq-zc706-eval.cfg]
+#    adapter_khz 2000
+#    init
+#
+
+if { [info exists CHIPNAME] } {
+    global _CHIPNAME
+    set _CHIPNAME $CHIPNAME
+} else {
+    global _CHIPNAME
+    set _CHIPNAME zynq
+}
+
+if { [info exists ENDIAN] } {
+    set _ENDIAN $ENDIAN
+} else {
+    # this defaults to a bigendian
+    set _ENDIAN little
+}
+
+if { [info exists SMP] } {
+    global _SMP
+    set _SMP 1
+} else {
+    global _SMP
+    set _SMP 0
+}
+
+#
+# PL Tap.
+#
+# See ug585 ZYNQ-7000 TRM PSS_IDCODE for how this number is constructed.
+#   0x03731093 - ZC706 Eval board 1.1
+#   0x23731093 - ??
+#   0x23727093 - Zedboard Rev. C and D
+#
+# Set in your configuration file or board specific file.
+#
+if { [info exists PL_TAPID] } {
+    set _PL_TAPID $PL_TAPID
+} else {
+    set _PL_TAPID 0x03731093
+}
+
+jtag newtap $_CHIPNAME tap -irlen 6 -ircapture 0x001 -irmask 0x003 \
+    -expected-id $_PL_TAPID
+
+#
+# CoreSight Debug Access Port
+#
+if { [info exists DAP_TAPID] } {
+    set _DAP_TAPID $DAP_TAPID
+} else {
+    set _DAP_TAPID 0x4ba00477
+}
+
+jtag newtap $_CHIPNAME dap -irlen 4 -ircapture 0x01 -irmask 0x03 \
+    -expected-id $_DAP_TAPID
+
+#
+# GDB target: Cortex-A9, using DAP, configuring only one core
+# Base addresses of cores:
+# core 0  -  0xF8890000
+# core 1  -  0xF8892000
+#
+# Read from the ROM table with the patch to read the nested table.
+#
+
+set _TARGETNAME_0 $_CHIPNAME.cpu.0
+set _TARGETNAME_1 $_CHIPNAME.cpu.1
+
+target create $_TARGETNAME_0 cortex_a -coreid 0 \
+    -endian $_ENDIAN \
+    -chain-position $_CHIPNAME.dap \
+    -dbgbase 0x80090000
+if { $_SMP } {
+    echo "Zynq CPU1."
+    target create $_TARGETNAME_1 cortex_a -coreid 1 \
+        -endian $_ENDIAN \
+        -chain-position $_CHIPNAME.dap \
+        -dbgbase 0x80092000
+    target smp $_TARGETNAME_0 $_TARGETNAME_1
+}
+
+#
+# Hack to get the registers into a stable state when first booting a zynq in
+# JTAG mode. If r11 is pointing to an invalid address and you use gdb to set a
+# register the write will fail because gdb attempts to scan or unwind the
+# current frame and the bad address seems to lock the bus up. This code puts
+# the registers into the OCM and hopefull safe.
+#
+proc zynq_clear_registers { target } {
+    echo "Zynq-7000 Series setup: $target"
+    set _OCM_END 0x0003FFF0
+    mww phys 0xF8007000 0x4E00E07F
+    reg r0 0
+    reg r1 0
+    reg r2 0
+    reg r3 0
+    reg r4 0
+    reg r5 0
+    reg r6 0
+    reg r7 0
+    reg r8 0
+    reg r9 0
+    reg r10 0
+    reg r11 $_OCM_END
+    reg sp_svc $_OCM_END
+    reg lr_svc $_OCM_END
+    reg sp_abt $_OCM_END
+    reg lr_abt $_OCM_END
+    reg sp_und $_OCM_END
+    reg lr_und $_OCM_END
+}
+
+proc zynq_disable_mmu_and_caches { target } {
+    # arm mcr pX op1 CRn CRm op2 value
+    echo "Disable MMU and caches"
+    # Invalidate caches
+    catch {
+        $target arm mcr 15 0 7 5 0 0
+        $target arm mcr 15 0 7 7 0 0
+        # Invalidate all TLBs
+        $target arm mcr 15 0 8 5 0 0
+        $target arm mcr 15 0 8 6 0 0
+        $target arm mcr 15 0 8 7 0 0
+        $target arm mcr 15 4 8 3 0 0
+        $target arm mcr 15 4 8 7 0 0
+        set cp [$target arm mrc 15 0 1 0 0]
+        echo "SCTRL => [format 0x%x $cp]"
+        set mask [expr 1 << 29 | 1 << 12 | 1 << 11 | 1 << 2 | 1 << 1 | 1 << 0]
+        set cp [expr ($cp & ~$mask)]
+        $target arm mcr 15 0 1 0 0 $cp
+        echo "SCTRL <= [format 0x%x $cp]"
+    }
+}
+
+proc zynq_boot_ocm_setup { } {
+    #
+    # Enable the OCM
+    #
+    echo "Zynq Boot OCM setup"
+    catch {
+      mww phys 0xF8000008 0xDF0D
+      mww phys 0xF8000238 0
+      mww phys 0xF8000910 0xC
+    }
+}
+
+proc zynq_rtems_setup { } {
+    cache_config l2x 0xF8F02000 8
+    cortex_a maskisr on
+}
+
+proc zynq_restart { wait } {
+    global _SMP
+    global _TARGETNAME_0
+    global _TARGETNAME_1
+    set target0 $_TARGETNAME_0
+    set target1 $_TARGETNAME_1
+    echo "Zynq reset, resetting the board ... "
+    poll off
+    #
+    # Issue the reset via the SLCR
+    #
+    catch {
+        mww phys 0xF8000008 0xDF0D
+        mww phys 0xF8000200 1
+    }
+    echo "Zynq reset waiting for $wait msecs ... "
+    sleep $wait
+    #
+    # Reconnect the DAP etc due to the reset.
+    #
+    $target0 cortex_a dbginit
+    $target0 arm core_state arm
+    if { $_SMP } {
+        $target1 arm core_state arm
+        $target1 cortex_a dbginit
+        cortex_a smp_off
+    }
+    poll on
+    #
+    # We can now halt the core.
+    #
+    if { $_SMP } {
+        targets $target1
+        halt
+    }
+    targets $target0
+    halt
+    zynq_rtems_setup
+}
+
+proc zynq_gdb_attach { target } {
+    catch {
+      halt
+    }
+}

remote_run.sh

@@ -2,63 +2,29 @@
 
 set -e
 
-if [ -z "$OPENOCD_ZYNQ" ]; then
-    echo "OPENOCD_ZYNQ environment variable must be set"
-    exit 1
-fi
-if [ -z "$SZL" ]; then
-    echo "SZL environment variable must be set"
-    exit 1
-fi
-
 target_host="rpi-4.m-labs.hk"
 impure=0
-pure_dir="result"
-impure_dir="build"
-sshopts=""
-load_bitstream=1
-board_host="192.168.1.52"
 
-while getopts "h:id:o:l" opt; do
+while getopts "h:i" opt; do
     case "$opt" in
-    \?) exit 1
+    \?) exit 0
         ;;
     h)  target_host=$OPTARG
         ;;
     i)  impure=1
         ;;
-    d)  pure_dir=$OPTARG;
-        impure_dir=$OPTARG;
-        ;;
-    o)  sshopts=$OPTARG
-        ;;
-    l)  load_bitstream=0
-        ;;
-    b)  board_host=$OPTARG
-        ;;
     esac
 done
 
-target_folder="/tmp/zynq-$USER"
+target_folder=/tmp/zynq-\$USER
-load_bitstream_cmd=""
 
-echo "Creating $target_folder..."
+ssh $target_host "mkdir -p $target_folder"
-ssh $sshopts $target_host "mkdir -p $target_folder"
+rsync openocd/* $target_host:$target_folder
-echo "Copying files..."
-rsync -e "ssh $sshopts" -Lc $OPENOCD_ZYNQ/* $target_host:$target_folder
-rsync -e "ssh $sshopts" -Lc $SZL $target_host:$target_folder
 if [ $impure -eq 1 ]; then
-    if [ $load_bitstream -eq 1 ]; then
+    rsync build/firmware/armv7-none-eabihf/release/szl $target_host:$target_folder/szl.elf
-        load_bitstream_cmd="-g build/gateware/top.bit"
+    rsync build/gateware/top.bit $target_host:$target_folder
-    fi
-    firmware="build/runtime.bin"
 else
-    if [ $load_bitstream -eq 1 ]; then
+    rsync -L result/szl.elf $target_host:$target_folder
-        load_bitstream_cmd="-g $pure_dir/top.bit"
+    rsync -L result/top.bit $target_host:$target_folder
-    fi
-    firmware="$pure_dir/runtime.bin"    
 fi
-echo "Programming board..."
+ssh $target_host "cd $target_folder; openocd -f zc706.cfg -c 'pld load 0 top.bit; load_image szl.elf; resume 0; exit'"
-ssh $sshopts $target_host "cd $target_folder; openocd -f zc706.cfg -c'load_image szl.elf; resume 0; exit'"
-sleep 5
-artiq_netboot $load_bitstream_cmd -f $firmware -b $board_host

rustPlatform.nix

@@ -0,0 +1,24 @@
+{ pkgs }:
+
+let
+  rustcSrc = pkgs.fetchgit {
+    url = "https://github.com/rust-lang/rust.git";
+    # master of 2020-04-10
+    rev = "94d346360da50f159e0dc777dc9bc3c5b6b51a00";
+    sha256 = "1hcqdz4w2vqb12rrqqcjbfs5s0w4qwjn7z45d1zh0fzncdcf6f7d";
+    fetchSubmodules = true;
+  };
+  rustManifest = ./channel-rust-nightly.toml;
+
+  targets = [];
+  rustChannelOfTargets = _channel: _date: targets:
+    (pkgs.lib.rustLib.fromManifestFile rustManifest {
+      inherit (pkgs) stdenv fetchurl patchelf;
+    }).rust.override { inherit targets; };
+  rust =
+    rustChannelOfTargets "nightly" null targets;
+in
+  pkgs.recurseIntoAttrs (pkgs.makeRustPlatform {
+    rustc = rust // { src = rustcSrc; };
+    cargo = rust;
+  })

shell.nix

@@ -1,12 +1,10 @@
 let
-  zynq-rs = (import ./zynq-rs.nix);
+  mozillaOverlay = import (builtins.fetchTarball "https://github.com/mozilla/nixpkgs-mozilla/archive/master.tar.gz");
-  pkgs = import <nixpkgs> { overlays = [ (import "${zynq-rs}/nix/mozilla-overlay.nix") ]; };
+  pkgs = import <nixpkgs> { overlays = [ mozillaOverlay ]; };
-  rustPlatform = (import "${zynq-rs}/nix/rust-platform.nix" { inherit pkgs; });
   artiq-fast = <artiq-fast>;
+  rustPlatform = (import ./rustPlatform.nix { inherit pkgs; });
   artiqpkgs = import "${artiq-fast}/default.nix" { inherit pkgs; };
   vivado = import "${artiq-fast}/vivado.nix" { inherit pkgs; };
-  cargo-xbuild = import ./cargo-xbuild.nix { inherit pkgs; };
-  zc706-szl = (import zynq-rs).zc706-szl;
 in
   pkgs.stdenv.mkDerivation {
     name = "artiq-zynq-env";
@@ -14,22 +12,19 @@ in
       pkgs.gnumake
       rustPlatform.rust.rustc
       rustPlatform.rust.cargo
-      pkgs.llvmPackages_9.llvm
+      pkgs.llvm_9
-      pkgs.llvmPackages_9.clang-unwrapped
+      pkgs.clang_9
       pkgs.cacert
-      cargo-xbuild
+      pkgs.cargo-xbuild
 
       pkgs.openocd
       pkgs.openssh pkgs.rsync
 
       (pkgs.python3.withPackages(ps: (with artiqpkgs; [ migen migen-axi misoc artiq ])))
       vivado
-      artiqpkgs.binutils-arm
 
-      (import "${zynq-rs}/nix/mkbootimage.nix" { inherit pkgs; })
+      (import ./mkbootimage.nix { inherit pkgs; })
     ];
 
     XARGO_RUST_SRC = "${rustPlatform.rust.rustc.src}/src";
-    OPENOCD_ZYNQ = "${zynq-rs}/openocd";
-    SZL = "${zc706-szl}/szl.elf";
   }

src/Cargo.lock

@@ -35,12 +35,6 @@ version = "1.3.4"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "08c48aae112d48ed9f069b33538ea9e3e90aa263cfa3d1c24309612b1f7472de"
 
-[[package]]
-name = "cc"
-version = "1.0.58"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "f9a06fb2e53271d7c279ec1efea6ab691c35a2ae67ec0d91d7acec0caf13b518"
-
 [[package]]
 name = "cfg-if"
 version = "0.1.10"
@@ -49,16 +43,13 @@ checksum = "4785bdd1c96b2a846b2bd7cc02e86b6b3dbf14e7e53446c4f54c92a361040822"
 
 [[package]]
 name = "compiler_builtins"
-version = "0.1.33"
+version = "0.1.32"
-source = "git+https://git.m-labs.hk/M-Labs/compiler-builtins-zynq.git#62a622ba62c671aaadce7c108854551086df41f8"
+source = "registry+https://github.com/rust-lang/crates.io-index"
-dependencies = [
+checksum = "7bc4ac2c824d2bfc612cba57708198547e9a26943af0632aff033e0693074d5c"
- "cc",
-]
 
 [[package]]
 name = "core_io"
 version = "0.1.20200410"
-source = "git+https://git.m-labs.hk/M-Labs/zynq-rs.git#7360984efbd772ae992ef00af09786b0ae8430f0"
 dependencies = [
  "memchr",
 ]
@@ -70,20 +61,25 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "0f8cb7306107e4b10e64994de6d3274bd08996a7c1322a27b86482392f96be0a"
 
 [[package]]
-name = "dwarf"
+name = "cstr_core"
-version = "0.0.0"
+version = "0.2.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "8758514b5f03968703f1db1f1e196e031d5268f5295ff99a5bf345008790ba85"
 dependencies = [
- "cfg-if",
+ "cty",
- "compiler_builtins",
+ "memchr",
- "libc",
- "unwind",
 ]
 
+[[package]]
+name = "cty"
+version = "0.2.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "7313c0d620d0cb4dbd9d019e461a4beb501071ff46ec0ab933efb4daa76d73e3"
+
 [[package]]
 name = "dyld"
 version = "0.1.0"
 dependencies = [
- "libcortex_a9",
  "log",
 ]
 
@@ -93,15 +89,15 @@ version = "0.2.4"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "fa998ce59ec9765d15216393af37a58961ddcefb14c753b4816ba2191d865fcb"
 dependencies = [
- "nb 0.1.3",
+ "nb",
  "void",
 ]
 
 [[package]]
 name = "fatfs"
-version = "0.3.4"
+version = "0.3.3"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "93079df23039e52059e1f03b4c29fb0c72da2c792aad91bb2236c9fb81d3592e"
+checksum = "f6d1df9e4503954f60504a5ee4fc435cd65cc42e98b2081f7f421be5f2e68e7d"
 dependencies = [
  "bitflags",
  "byteorder",
@@ -188,11 +184,11 @@ dependencies = [
 [[package]]
 name = "libasync"
 version = "0.0.0"
-source = "git+https://git.m-labs.hk/M-Labs/zynq-rs.git#7360984efbd772ae992ef00af09786b0ae8430f0"
+source = "git+https://git.m-labs.hk/M-Labs/zc706.git#ec252b099cf67a51ba9daa72b3292db8c21ba1b8"
 dependencies = [
  "embedded-hal",
  "libcortex_a9",
- "nb 0.1.3",
+ "nb",
  "pin-utils",
  "smoltcp",
 ]
@@ -200,58 +196,32 @@ dependencies = [
 [[package]]
 name = "libboard_zynq"
 version = "0.0.0"
-source = "git+https://git.m-labs.hk/M-Labs/zynq-rs.git#7360984efbd772ae992ef00af09786b0ae8430f0"
+source = "git+https://git.m-labs.hk/M-Labs/zc706.git#ec252b099cf67a51ba9daa72b3292db8c21ba1b8"
 dependencies = [
  "bit_field",
  "embedded-hal",
  "libcortex_a9",
  "libregister",
  "log",
- "nb 0.1.3",
+ "nb",
  "smoltcp",
  "void",
  "volatile-register",
 ]
 
-[[package]]
-name = "libc"
-version = "0.1.0"
-dependencies = [
- "cc",
- "libboard_zynq",
-]
-
-[[package]]
-name = "libconfig"
-version = "0.1.0"
-source = "git+https://git.m-labs.hk/M-Labs/zynq-rs.git#7360984efbd772ae992ef00af09786b0ae8430f0"
-dependencies = [
- "core_io",
- "fatfs",
- "libboard_zynq",
- "log",
-]
-
 [[package]]
 name = "libcortex_a9"
 version = "0.0.0"
-source = "git+https://git.m-labs.hk/M-Labs/zynq-rs.git#7360984efbd772ae992ef00af09786b0ae8430f0"
+source = "git+https://git.m-labs.hk/M-Labs/zc706.git#ec252b099cf67a51ba9daa72b3292db8c21ba1b8"
 dependencies = [
  "bit_field",
  "libregister",
- "volatile-register",
 ]
 
-[[package]]
-name = "libm"
-version = "0.2.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "c7d73b3f436185384286bd8098d17ec07c9a7d2388a6599f824d8502b529702a"
-
 [[package]]
 name = "libregister"
 version = "0.0.0"
-source = "git+https://git.m-labs.hk/M-Labs/zynq-rs.git#7360984efbd772ae992ef00af09786b0ae8430f0"
+source = "git+https://git.m-labs.hk/M-Labs/zc706.git#ec252b099cf67a51ba9daa72b3292db8c21ba1b8"
 dependencies = [
  "bit_field",
  "vcell",
@@ -261,7 +231,7 @@ dependencies = [
 [[package]]
 name = "libsupport_zynq"
 version = "0.0.0"
-source = "git+https://git.m-labs.hk/M-Labs/zynq-rs.git#7360984efbd772ae992ef00af09786b0ae8430f0"
+source = "git+https://git.m-labs.hk/M-Labs/zc706.git#ec252b099cf67a51ba9daa72b3292db8c21ba1b8"
 dependencies = [
  "compiler_builtins",
  "libboard_zynq",
@@ -273,25 +243,19 @@ dependencies = [
 
 [[package]]
 name = "linked_list_allocator"
-version = "0.8.5"
+version = "0.8.4"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "660b26e6156a7d00eefb19052fe1943cf5ab2f353a723a577fad6ba2f99d1f90"
+checksum = "e70e46c13c0e8374c26cec5752e3347ca1087d9711de8f45aa513a7700efd73d"
 
 [[package]]
 name = "log"
-version = "0.4.11"
+version = "0.4.8"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "4fabed175da42fed1fa0746b0ea71f412aa9d35e76e95e59b192c64b9dc2bf8b"
+checksum = "14b6052be84e6b71ab17edffc2eeabf5c2c3ae1fdb464aae35ac50c67a44e1f7"
 dependencies = [
  "cfg-if",
 ]
 
-[[package]]
-name = "log_buffer"
-version = "1.2.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "f033173c9486b7fe97a79c895c0a3483ae395ab6744c985d10078950e2492419"
-
 [[package]]
 name = "managed"
 version = "0.7.2"
@@ -306,24 +270,15 @@ checksum = "3728d817d99e5ac407411fa471ff9800a778d88a24685968b36824eaf4bee400"
 
 [[package]]
 name = "nb"
-version = "0.1.3"
+version = "0.1.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "801d31da0513b6ec5214e9bf433a77966320625a37860f910be265be6e18d06f"
+checksum = "b1411551beb3c11dedfb0a90a0fa256b47d28b9ec2cdff34c25a2fa59e45dbdc"
-dependencies = [
- "nb 1.0.0",
-]
-
-[[package]]
-name = "nb"
-version = "1.0.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "546c37ac5d9e56f55e73b677106873d9d9f5190605e41a856503623648488cae"
 
 [[package]]
 name = "num-derive"
-version = "0.3.1"
+version = "0.3.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "e0396233fb2d5b0ae3f05ff6aba9a09185f7f6e70f87fb01147d545f85364665"
+checksum = "0c8b15b261814f992e33760b1fca9fe8b693d8a65299f20c9901688636cfb746"
 dependencies = [
  "proc-macro2",
  "quote",
@@ -341,18 +296,18 @@ dependencies = [
 
 [[package]]
 name = "pin-project"
-version = "0.4.23"
+version = "0.4.22"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "ca4433fff2ae79342e497d9f8ee990d174071408f28f726d6d83af93e58e48aa"
+checksum = "12e3a6cdbfe94a5e4572812a0201f8c0ed98c1c452c7b8563ce2276988ef9c17"
 dependencies = [
  "pin-project-internal",
 ]
 
 [[package]]
 name = "pin-project-internal"
-version = "0.4.23"
+version = "0.4.22"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "2c0e815c3ee9a031fdf5af21c10aa17c573c9c6a566328d99e3936c34e36461f"
+checksum = "6a0ffd45cf79d88737d7cc85bfd5d2894bee1139b356e616fe85dc389c61aaf7"
 dependencies = [
  "proc-macro2",
  "quote",
@@ -367,9 +322,9 @@ checksum = "8b870d8c151b6f2fb93e84a13146138f05d02ed11c7e7c54f8826aaaf7c9f184"
 
 [[package]]
 name = "proc-macro-hack"
-version = "0.5.18"
+version = "0.5.16"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "99c605b9a0adc77b7211c6b1f722dcb613d68d66859a44f3d485a6da332b0598"
+checksum = "7e0456befd48169b9f13ef0f0ad46d492cf9d2dbb918bcf38e01eed4ce3ec5e4"
 
 [[package]]
 name = "proc-macro-nested"
@@ -379,9 +334,9 @@ checksum = "eba180dafb9038b050a4c280019bbedf9f2467b61e5d892dcad585bb57aadc5a"
 
 [[package]]
 name = "proc-macro2"
-version = "1.0.19"
+version = "1.0.18"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "04f5f085b5d71e2188cb8271e5da0161ad52c3f227a661a3c135fdf28e258b12"
+checksum = "beae6331a816b1f65d04c45b078fd8e6c93e8071771f41b8163255bbd8d7c8fa"
 dependencies = [
  "unicode-xid",
 ]
@@ -409,25 +364,16 @@ dependencies = [
  "byteorder",
  "core_io",
  "cslice",
- "dwarf",
  "dyld",
- "embedded-hal",
+ "fatfs",
  "futures",
  "libasync",
  "libboard_zynq",
- "libc",
- "libconfig",
  "libcortex_a9",
- "libm",
- "libregister",
  "libsupport_zynq",
  "log",
- "log_buffer",
- "nb 0.1.3",
  "num-derive",
  "num-traits",
- "unwind",
- "vcell",
  "void",
 ]
 
@@ -444,31 +390,32 @@ dependencies = [
 
 [[package]]
 name = "syn"
-version = "1.0.38"
+version = "1.0.33"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "e69abc24912995b3038597a7a593be5053eb0fb44f3cc5beec0deb421790c1f4"
+checksum = "e8d5d96e8cbb005d6959f119f773bfaebb5684296108fb32600c00cde305b2cd"
 dependencies = [
  "proc-macro2",
  "quote",
  "unicode-xid",
 ]
 
+[[package]]
+name = "szl"
+version = "0.1.0"
+dependencies = [
+ "cstr_core",
+ "libboard_zynq",
+ "libcortex_a9",
+ "libsupport_zynq",
+ "log",
+]
+
 [[package]]
 name = "unicode-xid"
 version = "0.2.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "f7fe0bb3479651439c9112f72b6c505038574c9fbb575ed1bf3b797fa39dd564"
 
-[[package]]
-name = "unwind"
-version = "0.0.0"
-dependencies = [
- "cc",
- "cfg-if",
- "compiler_builtins",
- "libc",
-]
-
 [[package]]
 name = "vcell"
 version = "0.1.2"

src/Cargo.toml

@@ -1,19 +1,22 @@
 [workspace]
 members = [
-  "libc",
   "libdyld",
-  "libdwarf",
+  "libcoreio",
-  "libunwind",
   "runtime",
+  "szl"
 ]
 
+[profile.dev]
+panic = "abort"
+lto = false
+
 [profile.release]
 panic = "abort"
 debug = true
-codegen-units = 1
+# Link-Time Optimization:
-opt-level = 2
+# turn off if you get unusable debug symbols.
 lto = true
+opt-level = 'z'  # Optimize for size.
 
 [patch.crates-io]
-core_io = { git = "https://git.m-labs.hk/M-Labs/zynq-rs.git" }
+core_io = { path = "./libcoreio" }
-compiler_builtins = { git = "https://git.m-labs.hk/M-Labs/compiler-builtins-zynq.git"}

src/Makefile

@@ -1,16 +1,20 @@
 VARIANT := simple
 
-all: ../build/firmware/armv7-none-eabihf/release/runtime ../build/runtime.bin
+all: ../build/firmware/armv7-none-eabihf/release/szl
 
 .PHONY: all
 
 
-../build/pl.rs ../build/rustc-cfg: gateware/*
+../build/pl.rs: zc706.py
 	mkdir -p ../build
-	python gateware/zc706.py -r ../build/pl.rs -c ../build/rustc-cfg -V $(VARIANT)
+	python zc706.py -r ../build/pl.rs -V $(VARIANT)
 
-../build/firmware/armv7-none-eabihf/release/runtime: ../build/pl.rs ../build/rustc-cfg $(shell find . -path ./szl -prune -o -print)
+../build/firmware/armv7-none-eabihf/release/runtime: .cargo/* armv7-none-eabihf.json Cargo.lock Cargo.toml libdyld/* libdyld/src/* libcoreio/* libcoreio/src/* libcoreio/src/io/* runtime/* runtime/src/* ../build/pl.rs
 	XBUILD_SYSROOT_PATH=`pwd`/../build/sysroot cargo xbuild --release -p runtime --target-dir ../build/firmware
 
-../build/runtime.bin: ../build/firmware/armv7-none-eabihf/release/runtime
+../build/szl-payload.bin.lzma: ../build/firmware/armv7-none-eabihf/release/runtime
-	llvm-objcopy -O binary ../build/firmware/armv7-none-eabihf/release/runtime ../build/runtime.bin
+	llvm-objcopy -O binary ../build/firmware/armv7-none-eabihf/release/runtime ../build/szl-payload.bin
+	lzma --keep -f ../build/szl-payload.bin
+
+../build/firmware/armv7-none-eabihf/release/szl: .cargo/* armv7-none-eabihf.json Cargo.lock Cargo.toml szl/* szl/src/* ../build/szl-payload.bin.lzma
+	XBUILD_SYSROOT_PATH=`pwd`/../build/sysroot cargo xbuild --release -p szl --target-dir ../build/firmware

src/armv7-none-eabihf.json

@@ -20,8 +20,6 @@
   "max-atomic-width": 32,
   "os": "none",
   "panic-strategy": "abort",
-  "requires-uwtable": true,
-  "force-unwind-tables": "yes",
   "relocation-model": "static",
   "target-c-int-width": "32",
   "target-endian": "little",

src/gateware/acpki.py

@@ -1,272 +0,0 @@
-from operator import attrgetter
-
-from migen import *
-from migen.genlib.cdc import MultiReg
-from migen_axi.interconnect import axi
-from misoc.interconnect.csr import *
-
-from artiq.gateware import rtio
-
-OUT_BURST_LEN = 10
-IN_BURST_LEN = 4
-
-
-class Engine(Module, AutoCSR):
-    def __init__(self, bus, user):
-        self.addr_base = CSRStorage(32)
-        self.trig_count = CSRStatus(32)
-        self.write_count = CSRStatus(32)
-
-        self.trigger_stb = Signal()
-
-        # Dout : Data received from CPU, output by DMA module
-        # Din : Data driven into DMA module, written into CPU
-        # When stb assert, index shows word being read/written, dout/din holds
-        # data
-        #
-        # Cycle:
-        # trigger_stb pulsed at start
-        # Then out_burst_len words are strobed out of dout
-        # Then, when din_ready is high, in_burst_len words are strobed in to din
-        self.dout_stb = Signal()
-        self.din_stb = Signal()
-        self.dout_index = Signal(max=16)
-        self.din_index = Signal(max=16)
-        self.din_ready = Signal()
-        self.dout = Signal(64)
-        self.din = Signal(64)
-
-        ###
-
-        self.sync += If(self.trigger_stb, self.trig_count.status.eq(self.trig_count.status+1))
-
-        self.comb += [
-            user.aruser.eq(0x1f),
-            user.awuser.eq(0x1f)
-        ]
-
-        ar, aw, w, r, b = attrgetter("ar", "aw", "w", "r", "b")(bus)
-
-        ### Read
-        self.comb += [
-            ar.addr.eq(self.addr_base.storage),
-            self.dout.eq(r.data),
-            r.ready.eq(1),
-            ar.burst.eq(axi.Burst.incr.value),
-            ar.len.eq(OUT_BURST_LEN-1), # Number of transfers in burst (0->1 transfer, 1->2 transfers...)
-            ar.size.eq(3), # Width of burst: 3 = 8 bytes = 64 bits
-            ar.cache.eq(0xf),
-        ]
-
-        # read control
-        self.submodules.read_fsm = read_fsm = FSM(reset_state="IDLE")
-        read_fsm.act("IDLE",
-            If(self.trigger_stb,
-                ar.valid.eq(1),
-                If(ar.ready,
-                    NextState("READ")
-                ).Else(
-                    NextState("READ_START")
-                )
-            )
-        )
-        read_fsm.act("READ_START",
-            ar.valid.eq(1),
-            If(ar.ready,
-                NextState("READ"),
-            )
-        )
-        read_fsm.act("READ",
-            ar.valid.eq(0),
-            If(r.last & r.valid,
-                NextState("IDLE")
-            )
-        )
-
-        self.sync += [
-            If(read_fsm.ongoing("IDLE"),
-                self.dout_index.eq(0)
-            ).Else(If(r.valid & read_fsm.ongoing("READ"),
-                    self.dout_index.eq(self.dout_index+1)
-                )
-            )
-        ]
-
-        self.comb += self.dout_stb.eq(r.valid & r.ready)
-
-        ### Write
-        self.comb += [
-            w.data.eq(self.din),
-            aw.addr.eq(self.addr_base.storage+96),
-            w.strb.eq(0xff),
-            aw.burst.eq(axi.Burst.incr.value),
-            aw.len.eq(IN_BURST_LEN-1), # Number of transfers in burst minus 1
-            aw.size.eq(3), # Width of burst: 3 = 8 bytes = 64 bits
-            aw.cache.eq(0xf),
-            b.ready.eq(1),
-        ]
-
-        # write control
-        self.submodules.write_fsm = write_fsm = FSM(reset_state="IDLE")
-        write_fsm.act("IDLE",
-            w.valid.eq(0),
-            aw.valid.eq(0),
-            If(self.trigger_stb,
-                aw.valid.eq(1),
-                If(aw.ready, # assumes aw.ready is not randomly deasserted
-                    NextState("DATA_WAIT")
-                ).Else(
-                    NextState("AW_READY_WAIT")
-                )
-            )
-        )
-        write_fsm.act("AW_READY_WAIT",
-            aw.valid.eq(1),
-            If(aw.ready,
-                NextState("DATA_WAIT"),
-            )
-        )
-        write_fsm.act("DATA_WAIT",
-            aw.valid.eq(0),
-            If(self.din_ready,
-                w.valid.eq(1),
-                NextState("WRITE")
-            )
-        )
-        write_fsm.act("WRITE",
-            w.valid.eq(1),
-            If(w.ready & w.last,
-                NextState("IDLE")
-            )
-        )
-
-        self.sync += If(w.ready & w.valid, self.write_count.status.eq(self.write_count.status+1))
-
-        self.sync += [
-            If(write_fsm.ongoing("IDLE"),
-                self.din_index.eq(0)
-            ),
-            If(w.ready & w.valid, self.din_index.eq(self.din_index+1))
-        ]
-
-        self.comb += [
-            w.last.eq(0),
-            If(self.din_index==aw.len, w.last.eq(1))
-        ]
-
-        self.comb += self.din_stb.eq(w.valid & w.ready)
-
-
-
-class KernelInitiator(Module, AutoCSR):
-    def __init__(self, tsc, bus, user, evento):
-        # Core is disabled upon reset to avoid spurious triggering if evento toggles from e.g. boot code.
-        self.enable = CSRStorage()
-
-        self.counter = CSRStatus(64)
-        self.counter_update = CSR()
-        self.o_status = CSRStatus(3)
-        self.i_status = CSRStatus(4)
-
-        self.submodules.engine = Engine(bus, user)
-        self.cri = rtio.cri.Interface()
-
-        ###
-
-        evento_stb = Signal()
-        evento_latched = Signal()
-        evento_latched_d = Signal()
-        self.specials += MultiReg(evento, evento_latched)
-        self.sync += evento_latched_d.eq(evento_latched)
-        self.comb += self.engine.trigger_stb.eq(self.enable.storage & (evento_latched != evento_latched_d))
-
-        cri = self.cri
-
-        cmd = Signal(8)
-        cmd_write = Signal()
-        cmd_read = Signal()
-        self.comb += [
-            cmd_write.eq(cmd == 0),
-            cmd_read.eq(cmd == 1)
-        ]
-
-        out_len = Signal(8)
-        dout_cases = {}
-        dout_cases[0] = [
-            cmd.eq(self.engine.dout[:8]),
-            out_len.eq(self.engine.dout[8:16]),
-            cri.chan_sel.eq(self.engine.dout[40:]),
-            cri.o_address.eq(self.engine.dout[32:40])
-        ]
-        for i in range(8):
-            target = cri.o_data[i*64:(i+1)*64]
-            dout_cases[0] += [If(i >= self.engine.dout[8:16], target.eq(0))]
-
-        dout_cases[1] = [
-            cri.o_timestamp.eq(self.engine.dout),
-            cri.i_timeout.eq(self.engine.dout)
-        ]
-        for i in range(8):
-            target = cri.o_data[i*64:(i+1)*64]
-            dout_cases[i+2] = [target.eq(self.engine.dout)]
-
-        self.sync += [
-            cri.cmd.eq(rtio.cri.commands["nop"]),
-            If(self.engine.dout_stb,
-                Case(self.engine.dout_index, dout_cases),
-                If(self.engine.dout_index == out_len + 2,
-                    If(cmd_write, cri.cmd.eq(rtio.cri.commands["write"])),
-                    If(cmd_read, cri.cmd.eq(rtio.cri.commands["read"]))
-                )
-            )
-        ]
-
-        # If input event, wait for response before allow input data to be
-        # sampled
-        # TODO: If output, wait for wait flag clear
-        RTIO_I_STATUS_WAIT_STATUS = 4
-        RTIO_O_STATUS_WAIT = 1
-
-        self.submodules.fsm = fsm = FSM(reset_state="IDLE")
-
-        fsm.act("IDLE",
-            If(self.engine.trigger_stb, NextState("WAIT_OUT_CYCLE"))
-        )
-        fsm.act("WAIT_OUT_CYCLE",
-            self.engine.din_ready.eq(0),
-            If(self.engine.dout_stb & cmd_write & (self.engine.dout_index == out_len + 2),
-               NextState("WAIT_READY")
-            ),
-            # for some reason read requires some delay until the next state
-            If(self.engine.dout_stb & cmd_read & (self.engine.dout_index == out_len + 3),
-                NextState("WAIT_READY")
-            )
-        )
-        fsm.act("WAIT_READY",
-            If(cmd_read & (cri.i_status & RTIO_I_STATUS_WAIT_STATUS == 0) \
-                | cmd_write & ~(cri.o_status & RTIO_O_STATUS_WAIT),
-                self.engine.din_ready.eq(1),
-                NextState("IDLE")
-            )
-        )
-
-        din_cases_cmdwrite = {
-            0: [self.engine.din.eq((1<<16) | cri.o_status)],
-            1: [self.engine.din.eq(0)],
-        }
-        din_cases_cmdread = {
-            0: [self.engine.din[:32].eq((1<<16) | cri.i_status), self.engine.din[32:].eq(cri.i_data)],
-            1: [self.engine.din.eq(cri.i_timestamp)]
-        }
-
-        self.comb += [
-            If(cmd_read, Case(self.engine.din_index, din_cases_cmdread)),
-            If(cmd_write, Case(self.engine.din_index, din_cases_cmdwrite)),
-        ]
-
-        # CRI CSRs
-        self.sync += If(self.counter_update.re, self.counter.status.eq(tsc.full_ts_cri))
-        self.comb += [
-            self.o_status.status.eq(self.cri.o_status),
-            self.i_status.status.eq(self.cri.i_status),
-        ]

src/gateware/analyzer.py

@@ -1,121 +0,0 @@
-from migen import *
-
-from misoc.interconnect.csr import *
-from misoc.interconnect import stream
-from migen_axi.interconnect import axi
-
-from artiq.gateware.rtio.analyzer import message_len, MessageEncoder
-
-import endianness
-
-
-class AXIDMAWriter(Module, AutoCSR):
-    def __init__(self, membus, max_outstanding_requests):
-        aw = len(membus.aw.addr)
-        dw = len(membus.w.data)
-        assert message_len % dw == 0
-        burst_length = message_len//dw
-        alignment_bits = log2_int(message_len//8)
-
-        self.reset = CSR()  # only apply when shut down
-        # All numbers in bytes
-        self.base_address = CSRStorage(aw, alignment_bits=alignment_bits)
-        self.last_address = CSRStorage(aw, alignment_bits=alignment_bits)
-        self.byte_count = CSRStatus(32)  # only read when shut down
-        self.bus_error = CSRStatus()
-
-        self.make_request = Signal()
-        self.sink = stream.Endpoint([("data", dw)])
-
-        # # #
-
-        outstanding_requests = Signal(max=max_outstanding_requests+1)
-        current_address = Signal(aw - alignment_bits)
-        self.comb += [
-            membus.aw.addr.eq(Cat(C(0, alignment_bits), current_address)),
-            membus.aw.id.eq(0),                   # Same ID for all transactions to forbid reordering.
-            membus.aw.burst.eq(axi.Burst.incr.value),
-            membus.aw.len.eq(burst_length-1),     # Number of transfers in burst (0->1 transfer, 1->2 transfers...).
-            membus.aw.size.eq(log2_int(dw//8)),   # Width of burst: 3 = 8 bytes = 64 bits.
-            membus.aw.cache.eq(0xf),
-            membus.aw.valid.eq(outstanding_requests != 0),
-        ]
-        self.sync += [
-            outstanding_requests.eq(outstanding_requests + self.make_request - (membus.aw.valid & membus.aw.ready)),
-
-            If(self.reset.re,
-                current_address.eq(self.base_address.storage)),
-            If(membus.aw.valid & membus.aw.ready,
-                If(current_address == self.last_address.storage,
-                    current_address.eq(self.base_address.storage)
-                ).Else(
-                    current_address.eq(current_address + 1)
-                )
-            )
-        ]
-
-        self.comb += [
-            membus.w.id.eq(0),
-            membus.w.valid.eq(self.sink.stb),
-            self.sink.ack.eq(membus.w.ready),
-            membus.w.data.eq(endianness.convert_signal(self.sink.data)),
-            membus.w.strb.eq(2**(dw//8)-1),
-        ]
-        beat_count = Signal(max=burst_length)
-        self.sync += [
-            If(membus.w.valid & membus.w.ready,
-                membus.w.last.eq(0),
-                If(membus.w.last,
-                    beat_count.eq(0)
-                ).Else(
-                    If(beat_count == burst_length-2, membus.w.last.eq(1)),
-                    beat_count.eq(beat_count + 1)
-                )
-            )
-        ]
-
-        message_count = Signal(32 - log2_int(message_len//8))
-        self.comb += self.byte_count.status.eq(
-            message_count << log2_int(message_len//8))
-        self.sync += [
-            If(self.reset.re, message_count.eq(0)),
-            If(membus.w.valid & membus.w.ready & membus.w.last, message_count.eq(message_count + 1))
-        ]
-
-        self.comb += membus.b.ready.eq(1)
-        self.sync += [
-            If(self.reset.re, self.bus_error.status.eq(0)),
-            If(membus.b.valid & membus.b.ready & (membus.b.resp != axi.Response.okay),
-                self.bus_error.status.eq(1))
-        ]
-
-
-class Analyzer(Module, AutoCSR):
-    def __init__(self, tsc, cri, membus, fifo_depth=128):
-        # shutdown procedure: set enable to 0, wait until busy=0
-        self.enable = CSRStorage()
-        self.busy = CSRStatus()
-
-        self.submodules.message_encoder = MessageEncoder(
-            tsc, cri, self.enable.storage)
-        self.submodules.fifo = stream.SyncFIFO(
-            [("data", message_len)], fifo_depth, True)
-        self.submodules.converter = stream.Converter(
-            message_len, len(membus.w.data), reverse=True)
-        self.submodules.dma = AXIDMAWriter(membus, max_outstanding_requests=fifo_depth)
-
-        enable_r = Signal()
-        self.sync += [
-            enable_r.eq(self.enable.storage),
-            If(self.enable.storage & ~enable_r,
-                self.busy.status.eq(1)),
-            If(self.dma.sink.stb & self.dma.sink.ack & self.dma.sink.eop,
-                self.busy.status.eq(0))
-        ]
-
-        self.comb += [
-            self.message_encoder.source.connect(self.fifo.sink),
-            self.fifo.source.connect(self.converter.sink),
-            self.converter.source.connect(self.dma.sink),
-            self.dma.make_request.eq(self.fifo.sink.stb & self.fifo.sink.ack)
-        ]

src/gateware/dma.py

@@ -1,157 +0,0 @@
-from migen import *
-from migen.genlib.fsm import FSM
-from misoc.interconnect.csr import *
-from misoc.interconnect import stream
-from migen_axi.interconnect import axi
-
-from artiq.gateware.rtio.dma import RawSlicer, RecordConverter, RecordSlicer, TimeOffset, CRIMaster
-
-import endianness
-
-
-AXI_BURST_LEN = 16
-
-
-class AXIReader(Module, AutoCSR):
-    def __init__(self, membus):
-        aw = len(membus.ar.addr)
-        dw = len(membus.r.data)
-        alignment_bits = log2_int(AXI_BURST_LEN*dw//8)
-        self.sink = stream.Endpoint([("address", aw - alignment_bits)])
-        self.source = stream.Endpoint([("data", dw)])
-
-        self.bus_error = CSRStatus()
-
-        # # #
-
-        eop_pending = Signal()
-        self.sync += [
-            If(self.sink.stb & self.sink.ack & self.sink.eop, eop_pending.eq(1)),
-            If(self.source.stb & self.source.ack & self.source.eop, eop_pending.eq(0)),
-        ]
-
-        self.comb += [
-            membus.ar.addr.eq(Cat(C(0, alignment_bits), self.sink.address)),
-            membus.ar.id.eq(0),                   # Same ID for all transactions to forbid reordering.
-            membus.ar.burst.eq(axi.Burst.incr.value),
-            membus.ar.len.eq(AXI_BURST_LEN-1),    # Number of transfers in burst (0->1 transfer, 1->2 transfers...).
-            membus.ar.size.eq(log2_int(dw//8)),   # Width of burst: 3 = 8 bytes = 64 bits.
-            membus.ar.cache.eq(0xf),
-            membus.ar.valid.eq(self.sink.stb & ~eop_pending),
-            self.sink.ack.eq(membus.ar.ready & ~eop_pending)
-        ]
-
-        # UG585: "Large slave interface read acceptance capability in the range of 14 to 70 commands"
-        inflight_cnt = Signal(max=128)
-        request_done = Signal()
-        reply_done = Signal()
-        self.comb += [
-            request_done.eq(membus.ar.valid & membus.ar.ready),
-            reply_done.eq(membus.r.valid & membus.r.ready & membus.r.last)
-        ]
-        self.sync += inflight_cnt.eq(inflight_cnt + request_done - reply_done)
-
-        self.comb += [
-            self.source.stb.eq(membus.r.valid),
-            membus.r.ready.eq(self.source.ack),
-            self.source.data.eq(endianness.convert_signal(membus.r.data)),
-            # Note that when eop_pending=1, no new transactions are made and inflight_cnt is no longer incremented
-            self.source.eop.eq(eop_pending & membus.r.last & (inflight_cnt == 1))
-        ]
-
-        stopped = Signal(reset=1)
-        self.sync += [
-            If(self.source.stb & self.source.ack & self.source.eop, stopped.eq(1)),
-            If(self.sink.stb & self.sink.ack, stopped.eq(0)),
-            If(stopped & (self.sink.stb & self.sink.ack),
-                # reset bus error status on new run
-                self.bus_error.status.eq(0)),
-            If(membus.r.valid & membus.r.valid & (membus.r.resp != axi.Response.okay),
-                self.bus_error.status.eq(1))
-        ]
-
-
-class DMAReader(Module, AutoCSR):
-    def __init__(self, membus, enable):
-        aw = len(membus.ar.addr)
-        alignment_bits = log2_int(AXI_BURST_LEN*len(membus.r.data)//8)
-
-        self.submodules.wb_reader = AXIReader(membus)
-        self.source = self.wb_reader.source
-
-        # All numbers in bytes
-        self.base_address = CSRStorage(aw, alignment_bits=alignment_bits)
-
-        # # #
-
-        enable_r = Signal()
-        address = self.wb_reader.sink
-        assert len(address.address) == len(self.base_address.storage)
-        self.sync += [
-            enable_r.eq(enable),
-            If(enable & ~enable_r,
-                address.address.eq(self.base_address.storage),
-                address.eop.eq(0),
-                address.stb.eq(1),
-            ),
-            If(address.stb & address.ack,
-                If(address.eop,
-                    address.stb.eq(0)
-                ).Else(
-                    address.address.eq(address.address + 1),
-                    If(~enable, address.eop.eq(1))
-                )
-            )
-        ]
-
-
-class DMA(Module):
-    def __init__(self, membus):
-        self.enable = CSR()
-
-        flow_enable = Signal()
-        self.submodules.dma = DMAReader(membus, flow_enable)
-        self.submodules.slicer = RecordSlicer(len(membus.r.data))
-        self.submodules.time_offset = TimeOffset()
-        self.submodules.cri_master = CRIMaster()
-        self.cri = self.cri_master.cri
-
-        self.comb += [
-            self.dma.source.connect(self.slicer.sink),
-            self.slicer.source.connect(self.time_offset.sink),
-            self.time_offset.source.connect(self.cri_master.sink)
-        ]
-
-        fsm = FSM(reset_state="IDLE")
-        self.submodules += fsm
-
-        fsm.act("IDLE",
-            If(self.enable.re, NextState("FLOWING"))
-        )
-        fsm.act("FLOWING",
-            self.enable.w.eq(1),
-            flow_enable.eq(1),
-            If(self.slicer.end_marker_found,
-                NextState("FLUSH")
-            )
-        )
-        fsm.act("FLUSH",
-            self.enable.w.eq(1),
-            self.slicer.flush.eq(1),
-            NextState("WAIT_EOP")
-        )
-        fsm.act("WAIT_EOP",
-            self.enable.w.eq(1),
-            If(self.cri_master.sink.stb & self.cri_master.sink.ack & self.cri_master.sink.eop,
-                NextState("WAIT_CRI_MASTER")
-            )
-        )
-        fsm.act("WAIT_CRI_MASTER",
-            self.enable.w.eq(1),
-            If(~self.cri_master.busy, NextState("IDLE"))
-        )
-
-    def get_csrs(self):
-        return ([self.enable] +
-                self.dma.get_csrs() + self.time_offset.get_csrs() +
-                self.cri_master.get_csrs())

src/gateware/endianness.py

@@ -1,21 +0,0 @@
-from migen import *
-
-
-def convert_signal(signal):
-    assert len(signal) % 8 == 0
-    nbytes = len(signal)//8
-    signal_bytes = []
-    for i in range(nbytes):
-        signal_bytes.append(signal[8*i:8*(i+1)])
-    return Cat(*reversed(signal_bytes))
-
-
-def convert_value(value, size):
-    assert size % 8 == 0
-    nbytes = size//8
-    result = 0
-    for i in range(nbytes):
-        result <<= 8
-        result |= value & 0xff
-        value >>= 8
-    return result

src/gateware/test_dma.py

@@ -1,236 +0,0 @@
-import unittest
-import random
-import itertools
-
-from migen import *
-from migen_axi.interconnect import axi
-
-from artiq.coredevice.exceptions import RTIOUnderflow, RTIODestinationUnreachable
-from artiq.gateware import rtio
-from artiq.gateware.rtio import cri
-from artiq.gateware.rtio.phy import ttl_simple
-
-import endianness
-import dma
-
-
-class AXIMemorySim:
-    def __init__(self, bus, data, max_queue=12):
-        self.bus = bus
-        self.data = data
-        self.max_queue = max_queue
-        self.align = len(bus.r.data)//8
-        self.queue = []
-
-    @passive
-    def ar(self):
-        while True:
-            if len(self.queue) < self.max_queue:
-                request = yield from self.bus.read_ar()
-                self.queue.append(request)
-            else:
-                yield
-
-    @passive
-    def r(self):
-        while True:
-            if self.queue:
-                request = self.queue.pop()
-                if request.burst:
-                    request_len = request.len + 1
-                else:
-                    request_len = 1
-                for i in range(request_len):
-                    if request.addr % self.align:
-                        raise ValueError
-                    addr = request.addr//self.align + i
-                    if addr < len(self.data):
-                        data = self.data[addr]
-                    else:
-                        data = 0
-                    data = endianness.convert_value(data, len(self.bus.r.data))
-                    yield from self.bus.write_r(request.id, data, last=i == request_len-1)
-            else:
-                yield
-
-
-def encode_n(n, min_length, max_length):
-    r = []
-    while n:
-        r.append(n & 0xff)
-        n >>= 8
-    r += [0]*(min_length - len(r))
-    if len(r) > max_length:
-        raise ValueError
-    return r
-
-
-def encode_record(channel, timestamp, address, data):
-    r = []
-    r += encode_n(channel, 3, 3)
-    r += encode_n(timestamp, 8, 8)
-    r += encode_n(address, 1, 1)
-    r += encode_n(data, 1, 64)
-    return encode_n(len(r)+1, 1, 1) + r
-
-
-def pack(x, size):
-    r = []
-    for i in range((len(x)+size-1)//size):
-        n = 0
-        for j in range(i*size, (i+1)*size):
-            n <<= 8
-            try:
-                n |= x[j]
-            except IndexError:
-                pass
-        r.append(n)
-    return r
-
-
-def encode_sequence(writes, ws):
-    sequence = [b for write in writes for b in encode_record(*write)]
-    sequence.append(0)
-    return pack(sequence, ws)
-
-
-def do_dma(dut, address):
-    yield from dut.dma.base_address.write(address)
-    yield from dut.enable.write(1)
-    yield
-    while ((yield from dut.enable.read())):
-        yield
-    error = yield from dut.cri_master.error.read()
-    if error & 1:
-        raise RTIOUnderflow
-    if error & 2:
-        raise RTIODestinationUnreachable
-
-
-test_writes1 = [
-    (0x01, 0x23, 0x12, 0x33),
-    (0x901, 0x902, 0x11, 0xeeeeeeeeeeeeeefffffffffffffffffffffffffffffff28888177772736646717738388488),
-    (0x81, 0x288, 0x88, 0x8888)
-]
-
-
-test_writes2 = [
-    (0x10, 0x10000, 0x20, 0x77),
-    (0x11, 0x10001, 0x22, 0x7777),
-    (0x12, 0x10002, 0x30, 0x777777),
-    (0x13, 0x10003, 0x40, 0x77777788),
-    (0x14, 0x10004, 0x50, 0x7777778899),
-]
-
-
-prng = random.Random(0)
-
-
-class TB(Module):
-    def __init__(self, ws):
-        sequence1 = encode_sequence(test_writes1, ws)
-        sequence2 = encode_sequence(test_writes2, ws)
-        offset = 512//ws
-        assert len(sequence1) < offset
-        sequence = (
-            sequence1 +
-            [prng.randrange(2**(ws*8)) for _ in range(offset-len(sequence1))] +
-            sequence2)
-
-        bus = axi.Interface(ws*8)
-        self.memory = AXIMemorySim(bus, sequence)
-        self.submodules.dut = dma.DMA(bus)
-
-
-test_writes_full_stack = [
-    (0, 32, 0, 1),
-    (1, 40, 0, 1),
-    (0, 48, 0, 0),
-    (1, 50, 0, 0),
-]
-
-
-class FullStackTB(Module):
-    def __init__(self, ws):
-        self.ttl0 = Signal()
-        self.ttl1 = Signal()
-
-        self.submodules.phy0 = ttl_simple.Output(self.ttl0)
-        self.submodules.phy1 = ttl_simple.Output(self.ttl1)
-
-        rtio_channels = [
-            rtio.Channel.from_phy(self.phy0),
-            rtio.Channel.from_phy(self.phy1)
-        ]
-
-        sequence = encode_sequence(test_writes_full_stack, ws)
-
-        bus = axi.Interface(ws*8)
-        self.memory = AXIMemorySim(bus, sequence)
-        self.submodules.dut = dma.DMA(bus)
-        self.submodules.tsc = rtio.TSC("async")
-        self.submodules.rtio = rtio.Core(self.tsc, rtio_channels)
-        self.comb += self.dut.cri.connect(self.rtio.cri)
-
-
-class TestDMA(unittest.TestCase):
-    def test_dma_noerror(self):
-        tb = TB(8)
-
-        def do_writes():
-            yield from do_dma(tb.dut, 0)
-            yield from do_dma(tb.dut, 512)
-
-        received = []
-        @passive
-        def rtio_sim():
-            dut_cri = tb.dut.cri
-            while True:
-                cmd = yield dut_cri.cmd
-                if cmd == cri.commands["nop"]:
-                    pass
-                elif cmd == cri.commands["write"]:
-                    channel = yield dut_cri.chan_sel
-                    timestamp = yield dut_cri.o_timestamp
-                    address = yield dut_cri.o_address
-                    data = yield dut_cri.o_data
-                    received.append((channel, timestamp, address, data))
-
-                    yield dut_cri.o_status.eq(1)
-                    for i in range(prng.randrange(10)):
-                        yield
-                    yield dut_cri.o_status.eq(0)
-                else:
-                    self.fail("unexpected RTIO command")
-                yield
-
-        run_simulation(tb, [do_writes(), rtio_sim(), tb.memory.ar(), tb.memory.r()])
-        self.assertEqual(received, test_writes1 + test_writes2)
-
-    def test_full_stack(self):
-        tb = FullStackTB(8)
-
-        ttl_changes = []
-        @passive
-        def monitor():
-            old_ttl_states = [0, 0]
-            for time in itertools.count():
-                ttl_states = [
-                    (yield tb.ttl0),
-                    (yield tb.ttl1)
-                ]
-                for i, (old, new) in enumerate(zip(old_ttl_states, ttl_states)):
-                    if new != old:
-                        ttl_changes.append((time, i))
-                old_ttl_states = ttl_states
-                yield
-
-        run_simulation(tb, {"sys": [
-            do_dma(tb.dut, 0), monitor(),
-            (None for _ in range(70)),
-            tb.memory.ar(), tb.memory.r()
-        ]}, {"sys": 8, "rsys": 8, "rtio": 8, "rio": 8, "rio_phy": 8})
-
-        correct_changes = [(timestamp + 11, channel)
-                           for channel, timestamp, _, _ in test_writes_full_stack]
-        self.assertEqual(ttl_changes, correct_changes)

src/gateware/zc706.py

@@ -1,309 +0,0 @@
-#!/usr/bin/env python
-
-import argparse
-from operator import itemgetter
-
-from migen import *
-from migen.build.generic_platform import *
-from migen.genlib.resetsync import AsyncResetSynchronizer
-from migen.genlib.cdc import MultiReg
-from migen_axi.integration.soc_core import SoCCore
-from migen_axi.platforms import zc706
-from misoc.interconnect.csr import *
-from misoc.integration import cpu_interface
-
-from artiq.gateware import rtio, nist_clock, nist_qc2
-from artiq.gateware.rtio.phy import ttl_simple, ttl_serdes_7series, dds, spi2
-
-import dma
-import analyzer
-import acpki
-
-
-class RTIOCRG(Module, AutoCSR):
-    def __init__(self, platform, rtio_internal_clk):
-        self.clock_sel = CSRStorage()
-        self.pll_reset = CSRStorage(reset=1)
-        self.pll_locked = CSRStatus()
-        self.clock_domains.cd_rtio = ClockDomain()
-        self.clock_domains.cd_rtiox4 = ClockDomain(reset_less=True)
-
-        rtio_external_clk = Signal()
-        user_sma_clock = platform.request("user_sma_clock")
-        platform.add_period_constraint(user_sma_clock.p, 8.0)
-        self.specials += Instance("IBUFDS",
-                                  i_I=user_sma_clock.p, i_IB=user_sma_clock.n,
-                                  o_O=rtio_external_clk)
-
-        pll_locked = Signal()
-        rtio_clk = Signal()
-        rtiox4_clk = Signal()
-        self.specials += [
-            Instance("PLLE2_ADV",
-                     p_STARTUP_WAIT="FALSE", o_LOCKED=pll_locked,
-
-                     p_REF_JITTER1=0.01,
-                     p_CLKIN1_PERIOD=8.0, p_CLKIN2_PERIOD=8.0,
-                     i_CLKIN1=rtio_internal_clk, i_CLKIN2=rtio_external_clk,
-                     # Warning: CLKINSEL=0 means CLKIN2 is selected
-                     i_CLKINSEL=~self.clock_sel.storage,
-
-                     # VCO @ 1GHz when using 125MHz input
-                     p_CLKFBOUT_MULT=8, p_DIVCLK_DIVIDE=1,
-                     i_CLKFBIN=self.cd_rtio.clk,
-                     i_RST=self.pll_reset.storage,
-
-                     o_CLKFBOUT=rtio_clk,
-
-                     p_CLKOUT0_DIVIDE=2, p_CLKOUT0_PHASE=0.0,
-                     o_CLKOUT0=rtiox4_clk),
-            Instance("BUFG", i_I=rtio_clk, o_O=self.cd_rtio.clk),
-            Instance("BUFG", i_I=rtiox4_clk, o_O=self.cd_rtiox4.clk),
-            AsyncResetSynchronizer(self.cd_rtio, ~pll_locked),
-            MultiReg(pll_locked, self.pll_locked.status)
-        ]
-
-
-class ZC706(SoCCore):
-    def __init__(self, acpki=False):
-        self.acpki = acpki
-        self.rustc_cfg = dict()
-
-        platform = zc706.Platform()
-        platform.toolchain.bitstream_commands.extend([
-            "set_property BITSTREAM.GENERAL.COMPRESS True [current_design]",
-        ])
-        ident = self.__class__.__name__
-        if self.acpki:
-            ident = "acpki_" + ident
-        SoCCore.__init__(self, platform=platform, csr_data_width=32, ident=ident)
-
-        platform.add_platform_command("create_clock -name clk_fpga_0 -period 8 [get_pins \"PS7/FCLKCLK[0]\"]")
-        platform.add_platform_command("set_input_jitter clk_fpga_0 0.24")
-
-        self.submodules.rtio_crg = RTIOCRG(self.platform, self.ps7.cd_sys.clk)
-        self.csr_devices.append("rtio_crg")
-        self.platform.add_period_constraint(self.rtio_crg.cd_rtio.clk, 8.)
-        self.platform.add_false_path_constraints(
-            self.ps7.cd_sys.clk,
-            self.rtio_crg.cd_rtio.clk)
-
-    def add_rtio(self, rtio_channels):
-        self.submodules.rtio_tsc = rtio.TSC("async", glbl_fine_ts_width=3)
-        self.submodules.rtio_core = rtio.Core(self.rtio_tsc, rtio_channels)
-        self.csr_devices.append("rtio_core")
-
-        if self.acpki:
-            self.rustc_cfg["ki_impl"] = "acp"
-            self.submodules.rtio = acpki.KernelInitiator(self.rtio_tsc,
-                                                         bus=self.ps7.s_axi_acp,
-                                                         user=self.ps7.s_axi_acp_user,
-                                                         evento=self.ps7.event.o)
-            self.csr_devices.append("rtio")
-        else:
-            self.rustc_cfg["ki_impl"] = "csr"
-            self.submodules.rtio = rtio.KernelInitiator(self.rtio_tsc, now64=True)
-            self.csr_devices.append("rtio")
-
-        self.submodules.rtio_dma = dma.DMA(self.ps7.s_axi_hp0)
-        self.csr_devices.append("rtio_dma")
-
-        self.submodules.cri_con = rtio.CRIInterconnectShared(
-            [self.rtio.cri, self.rtio_dma.cri],
-            [self.rtio_core.cri])
-        self.csr_devices.append("cri_con")
-
-        self.submodules.rtio_moninj = rtio.MonInj(rtio_channels)
-        self.csr_devices.append("rtio_moninj")
-
-        self.submodules.rtio_analyzer = analyzer.Analyzer(self.rtio_tsc, self.rtio_core.cri,
-                                                          self.ps7.s_axi_hp1)
-        self.csr_devices.append("rtio_analyzer")
-
-
-class Simple(ZC706):
-    def __init__(self, **kwargs):
-        ZC706.__init__(self, **kwargs)
-
-        platform = self.platform
-
-        rtio_channels = []
-        for i in range(4):
-            phy = ttl_simple.Output(platform.request("user_led", i))
-            self.submodules += phy
-            rtio_channels.append(rtio.Channel.from_phy(phy))
-
-        self.config["RTIO_LOG_CHANNEL"] = len(rtio_channels)
-        rtio_channels.append(rtio.LogChannel())
-
-        self.add_rtio(rtio_channels)
-
-
-# The NIST backplanes require setting VADJ to 3.3V by reprogramming the power supply.
-# This also changes the I/O standard for some on-board LEDs.
-leds_fmc33 = [
-    ("user_led_33", 0, Pins("Y21"), IOStandard("LVCMOS33")),
-    ("user_led_33", 1, Pins("G2"), IOStandard("LVCMOS15")),
-    ("user_led_33", 2, Pins("W21"), IOStandard("LVCMOS33")),
-    ("user_led_33", 3, Pins("A17"), IOStandard("LVCMOS15")),
-]
-
-
-class NIST_CLOCK(ZC706):
-    """
-    NIST clock hardware, with old backplane and 11 DDS channels
-    """
-    def __init__(self, **kwargs):
-        ZC706.__init__(self, **kwargs)
-
-        platform = self.platform
-        platform.add_extension(nist_clock.fmc_adapter_io)
-        platform.add_extension(leds_fmc33)
-
-        rtio_channels = []
-
-        for i in range(4):
-            phy = ttl_simple.Output(platform.request("user_led_33", i))
-            self.submodules += phy
-            rtio_channels.append(rtio.Channel.from_phy(phy))
-
-        for i in range(16):
-            if i % 4 == 3:
-                phy = ttl_serdes_7series.InOut_8X(platform.request("ttl", i))
-                self.submodules += phy
-                rtio_channels.append(rtio.Channel.from_phy(phy, ififo_depth=512))
-            else:
-                phy = ttl_serdes_7series.Output_8X(platform.request("ttl", i))
-                self.submodules += phy
-                rtio_channels.append(rtio.Channel.from_phy(phy))
-
-        for i in range(2):
-            phy = ttl_serdes_7series.InOut_8X(platform.request("pmt", i))
-            self.submodules += phy
-            rtio_channels.append(rtio.Channel.from_phy(phy, ififo_depth=512))
-
-        phy = ttl_simple.ClockGen(platform.request("la32_p"))
-        self.submodules += phy
-        rtio_channels.append(rtio.Channel.from_phy(phy))
-
-        for i in range(3):
-            phy = spi2.SPIMaster(self.platform.request("spi", i))
-            self.submodules += phy
-            rtio_channels.append(rtio.Channel.from_phy(
-                phy, ififo_depth=128))
-
-        phy = dds.AD9914(platform.request("dds"), 11, onehot=True)
-        self.submodules += phy
-        rtio_channels.append(rtio.Channel.from_phy(phy, ififo_depth=4))
-
-        self.config["RTIO_LOG_CHANNEL"] = len(rtio_channels)
-        rtio_channels.append(rtio.LogChannel())
-
-        self.add_rtio(rtio_channels)
-
-
-class NIST_QC2(ZC706):
-    """
-    NIST QC2 hardware, as used in Quantum I and Quantum II, with new backplane
-    and 24 DDS channels.  Two backplanes are used.
-    """
-    def __init__(self, **kwargs):
-        ZC706.__init__(self, **kwargs)
-
-        platform = self.platform
-        platform.add_extension(nist_qc2.fmc_adapter_io)
-        platform.add_extension(leds_fmc33)
-
-        rtio_channels = []
-
-        for i in range(4):
-            phy = ttl_simple.Output(platform.request("user_led_33", i))
-            self.submodules += phy
-            rtio_channels.append(rtio.Channel.from_phy(phy))
-
-        # All TTL channels are In+Out capable
-        for i in range(40):
-            phy = ttl_serdes_7series.InOut_8X(platform.request("ttl", i))
-            self.submodules += phy
-            rtio_channels.append(rtio.Channel.from_phy(phy, ififo_depth=512))
-
-        # CLK0, CLK1 are for clock generators, on backplane SMP connectors
-        for i in range(2):
-            phy = ttl_simple.ClockGen(
-                platform.request("clkout", i))
-            self.submodules += phy
-            rtio_channels.append(rtio.Channel.from_phy(phy))
-
-        for i in range(4):
-            phy = spi2.SPIMaster(self.platform.request("spi", i))
-            self.submodules += phy
-            rtio_channels.append(rtio.Channel.from_phy(
-                phy, ififo_depth=128))
-
-        for backplane_offset in range(2):
-            phy = dds.AD9914(
-                platform.request("dds", backplane_offset), 12, onehot=True)
-            self.submodules += phy
-            rtio_channels.append(rtio.Channel.from_phy(phy, ififo_depth=4))
-
-        self.config["RTIO_LOG_CHANNEL"] = len(rtio_channels)
-        rtio_channels.append(rtio.LogChannel())
-
-        self.add_rtio(rtio_channels)
-
-
-VARIANTS = {cls.__name__.lower(): cls for cls in [Simple, NIST_CLOCK, NIST_QC2]}
-
-
-def write_csr_file(soc, filename):
-    with open(filename, "w") as f:
-        f.write(cpu_interface.get_csr_rust(
-            soc.get_csr_regions(), soc.get_csr_groups(), soc.get_constants()))
-
-
-def write_rustc_cfg_file(soc, filename):
-    with open(filename, "w") as f:
-        for k, v in sorted(soc.rustc_cfg.items(), key=itemgetter(0)):
-            if v is None:
-                f.write("{}\n".format(k))
-            else:
-                f.write("{}=\"{}\"\n".format(k, v))
-
-
-def main():
-    parser = argparse.ArgumentParser(
-        description="ARTIQ port to the ZC706 Zynq development kit")
-    parser.add_argument("-r", default=None,
-        help="build Rust interface into the specified file")
-    parser.add_argument("-c", default=None,
-        help="build Rust compiler configuration into the specified file")
-    parser.add_argument("-g", default=None,
-        help="build gateware into the specified directory")
-    parser.add_argument("-V", "--variant", default="simple",
-                        help="variant: "
-                             "[acpki_]simple/nist_clock/nist_qc2 "
-                             "(default: %(default)s)")
-    args = parser.parse_args()
-
-    variant = args.variant.lower()
-    acpki = variant.startswith("acpki_")
-    if acpki:
-        variant = variant[6:]
-    try:
-        cls = VARIANTS[variant]
-    except KeyError:
-        raise SystemExit("Invalid variant (-V/--variant)")
-
-    soc = cls(acpki=acpki)
-    soc.finalize()
-
-    if args.r is not None:
-        write_csr_file(soc, args.r)
-    if args.c is not None:
-        write_rustc_cfg_file(soc, args.c)
-    if args.g is not None:
-        soc.build(build_dir=args.g)
-
-
-if __name__ == "__main__":
-    main()

src/include/_ansi.h

@@ -1,82 +0,0 @@
-/* Provide support for both ANSI and non-ANSI environments.  */
-
-/* To get a strict ANSI C environment, define macro __STRICT_ANSI__.  This will
-   "comment out" the non-ANSI parts of the ANSI header files (non-ANSI header
-   files aren't affected).  */
-
-#ifndef	_ANSIDECL_H_
-#define	_ANSIDECL_H_
-
-#include <newlib.h>
-#include <sys/config.h>
-
-/*  ISO C++.  */
-
-#ifdef __cplusplus
-#if !(defined(_BEGIN_STD_C) && defined(_END_STD_C))
-#ifdef _HAVE_STD_CXX
-#define _BEGIN_STD_C namespace std { extern "C" {
-#define _END_STD_C  } }
-#else
-#define _BEGIN_STD_C extern "C" {
-#define _END_STD_C  }
-#endif
-#if __GNUC_PREREQ (3, 3)
-#define _NOTHROW __attribute__ ((__nothrow__))
-#else
-#define _NOTHROW throw()
-#endif
-#endif
-#else
-#define _BEGIN_STD_C
-#define _END_STD_C
-#define _NOTHROW
-#endif
-
-#ifndef _LONG_DOUBLE
-#define _LONG_DOUBLE long double
-#endif
-
-/* Support gcc's __attribute__ facility.  */
-
-#ifdef __GNUC__
-#define _ATTRIBUTE(attrs) __attribute__ (attrs)
-#else
-#define _ATTRIBUTE(attrs)
-#endif
-
-/*  The traditional meaning of 'extern inline' for GCC is not
-  to emit the function body unless the address is explicitly
-  taken.  However this behaviour is changing to match the C99
-  standard, which uses 'extern inline' to indicate that the
-  function body *must* be emitted.  Likewise, a function declared
-  without either 'extern' or 'static' defaults to extern linkage
-  (C99 6.2.2p5), and the compiler may choose whether to use the
-  inline version or call the extern linkage version (6.7.4p6).
-  If we are using GCC, but do not have the new behaviour, we need
-  to use extern inline; if we are using a new GCC with the
-  C99-compatible behaviour, or a non-GCC compiler (which we will
-  have to hope is C99, since there is no other way to achieve the
-  effect of omitting the function if it isn't referenced) we use
-  'static inline', which c99 defines to mean more-or-less the same
-  as the Gnu C 'extern inline'.  */
-#if defined(__GNUC__) && !defined(__GNUC_STDC_INLINE__)
-/* We're using GCC, but without the new C99-compatible behaviour.  */
-#define _ELIDABLE_INLINE extern __inline__ _ATTRIBUTE ((__always_inline__))
-#else
-/* We're using GCC in C99 mode, or an unknown compiler which
-  we just have to hope obeys the C99 semantics of inline.  */
-#define _ELIDABLE_INLINE static __inline__
-#endif
-
-#if __GNUC_PREREQ (3, 1)
-#define _NOINLINE		__attribute__ ((__noinline__))
-#define _NOINLINE_STATIC	_NOINLINE static
-#else
-/* On non-GNU compilers and GCC prior to version 3.1 the compiler can't be
-   trusted not to inline if it is static. */
-#define _NOINLINE
-#define _NOINLINE_STATIC
-#endif
-
-#endif /* _ANSIDECL_H_ */

src/include/_newlib_version.h

@@ -1,12 +0,0 @@
-/* _newlib_version.h.  Generated from _newlib_version.hin by configure.  */
-/* Version macros for internal and downstream use. */
-#ifndef _NEWLIB_VERSION_H__
-#define _NEWLIB_VERSION_H__ 1
-
-#define _NEWLIB_VERSION "3.1.0"
-#define __NEWLIB__ 3
-#define __NEWLIB_MINOR__ 1
-#define __NEWLIB_PATCHLEVEL__ 0
-
-#endif /* !_NEWLIB_VERSION_H__ */
-

src/include/alloca.h

@@ -1,21 +0,0 @@
-/* libc/include/alloca.h - Allocate memory on stack */
-
-/* Written 2000 by Werner Almesberger */
-/* Rearranged for general inclusion by stdlib.h.
-   2001, Corinna Vinschen <vinschen@redhat.com> */
-
-#ifndef _NEWLIB_ALLOCA_H
-#define _NEWLIB_ALLOCA_H
-
-#include "_ansi.h"
-#include <sys/reent.h>
-
-#undef alloca
-
-#ifdef __GNUC__
-#define alloca(size) __builtin_alloca(size)
-#else
-void * alloca (size_t);
-#endif
-
-#endif

src/include/assert.h

@@ -1,50 +0,0 @@
-/*
-	assert.h
-*/
-
-#ifdef __cplusplus
-extern "C" {
-#endif
-
-#include "_ansi.h"
-
-#undef assert
-
-#ifdef NDEBUG           /* required by ANSI standard */
-# define assert(__e) ((void)0)
-#else
-# define assert(__e) ((__e) ? (void)0 : __assert_func (__FILE__, __LINE__, \
-						       __ASSERT_FUNC, #__e))
-
-# ifndef __ASSERT_FUNC
-  /* Use g++'s demangled names in C++.  */
-#  if defined __cplusplus && defined __GNUC__
-#   define __ASSERT_FUNC __PRETTY_FUNCTION__
-
-  /* C99 requires the use of __func__.  */
-#  elif __STDC_VERSION__ >= 199901L
-#   define __ASSERT_FUNC __func__
-
-  /* Older versions of gcc don't have __func__ but can use __FUNCTION__.  */
-#  elif __GNUC__ >= 2
-#   define __ASSERT_FUNC __FUNCTION__
-
-  /* failed to detect __func__ support.  */
-#  else
-#   define __ASSERT_FUNC ((char *) 0)
-#  endif
-# endif /* !__ASSERT_FUNC */
-#endif /* !NDEBUG */
-
-void __assert (const char *, int, const char *)
-	    _ATTRIBUTE ((__noreturn__));
-void __assert_func (const char *, int, const char *, const char *)
-	    _ATTRIBUTE ((__noreturn__));
-
-#if __STDC_VERSION__ >= 201112L && !defined __cplusplus
-# define static_assert _Static_assert
-#endif
-
-#ifdef __cplusplus
-}
-#endif

src/include/inttypes.h

@@ -1,345 +0,0 @@
-/*
- * Copyright (c) 2004, 2005 by
- * Ralf Corsepius, Ulm/Germany. All rights reserved.
- *
- * Permission to use, copy, modify, and distribute this software
- * is freely granted, provided that this notice is preserved.
- */
-
-/**
- *  @file  inttypes.h
- */
-
-#ifndef _INTTYPES_H
-#define _INTTYPES_H
-
-#include <newlib.h>
-#include <sys/config.h>
-#include <sys/_intsup.h>
-#include "_ansi.h"
-#include <stdint.h>
-#define __need_wchar_t
-#include <stddef.h>
-
-#if __BSD_VISIBLE
-#include <xlocale.h>
-#endif
-
-#define __STRINGIFY(a) #a
-
-/* 8-bit types */
-#define __PRI8(x) __INT8 __STRINGIFY(x)
-#define __PRI8LEAST(x) __LEAST8 __STRINGIFY(x)
-#define __PRI8FAST(x) __FAST8 __STRINGIFY(x)
-
-/* NOTICE: scanning 8-bit types requires use of the hh specifier
- * which is only supported on newlib platforms that
- * are built with C99 I/O format support enabled.  If the flag in
- * newlib.h hasn't been set during configuration to indicate this, the 8-bit
- * scanning format macros are disabled here as they result in undefined
- * behaviour which can include memory overwrite.  Overriding the flag after the
- * library has been built is not recommended as it will expose the underlying
- * undefined behaviour.
- */
-
-#if defined(_WANT_IO_C99_FORMATS)
-  #define __SCN8(x) __INT8 __STRINGIFY(x)
-	#define __SCN8LEAST(x) __LEAST8 __STRINGIFY(x)
-	#define __SCN8FAST(x) __FAST8 __STRINGIFY(x)
-#endif /* _WANT_IO_C99_FORMATS */
-
-
-#define PRId8		__PRI8(d)
-#define PRIi8		__PRI8(i)
-#define PRIo8		__PRI8(o)
-#define PRIu8		__PRI8(u)
-#define PRIx8		__PRI8(x)
-#define PRIX8		__PRI8(X)
-
-/* Macros below are only enabled for a newlib built with C99 I/O format support. */
-#if defined(_WANT_IO_C99_FORMATS)
-
-#define SCNd8		__SCN8(d)
-#define SCNi8		__SCN8(i)
-#define SCNo8		__SCN8(o)
-#define SCNu8		__SCN8(u)
-#define SCNx8		__SCN8(x)
-
-#endif /* _WANT_IO_C99_FORMATS */
-
-
-#define PRIdLEAST8	__PRI8LEAST(d)
-#define PRIiLEAST8	__PRI8LEAST(i)
-#define PRIoLEAST8	__PRI8LEAST(o)
-#define PRIuLEAST8	__PRI8LEAST(u)
-#define PRIxLEAST8	__PRI8LEAST(x)
-#define PRIXLEAST8	__PRI8LEAST(X)
-
-/* Macros below are only enabled for a newlib built with C99 I/O format support. */
-#if defined(_WANT_IO_C99_FORMATS)
-
-  #define SCNdLEAST8	__SCN8LEAST(d)
-  #define SCNiLEAST8	__SCN8LEAST(i)
-  #define SCNoLEAST8	__SCN8LEAST(o)
-  #define SCNuLEAST8	__SCN8LEAST(u)
-  #define SCNxLEAST8	__SCN8LEAST(x)
-
-#endif /* _WANT_IO_C99_FORMATS */
-
-#define PRIdFAST8	__PRI8FAST(d)
-#define PRIiFAST8	__PRI8FAST(i)
-#define PRIoFAST8	__PRI8FAST(o)
-#define PRIuFAST8	__PRI8FAST(u)
-#define PRIxFAST8	__PRI8FAST(x)
-#define PRIXFAST8	__PRI8FAST(X)
-
-/* Macros below are only enabled for a newlib built with C99 I/O format support. */
-#if defined(_WANT_IO_C99_FORMATS)
-
-  #define SCNdFAST8	__SCN8FAST(d)
-  #define SCNiFAST8	__SCN8FAST(i)
-  #define SCNoFAST8	__SCN8FAST(o)
-  #define SCNuFAST8	__SCN8FAST(u)
-  #define SCNxFAST8	__SCN8FAST(x)
-
-#endif /* _WANT_IO_C99_FORMATS */
-
-/* 16-bit types */
-#define __PRI16(x) __INT16 __STRINGIFY(x)
-#define __PRI16LEAST(x) __LEAST16 __STRINGIFY(x)
-#define __PRI16FAST(x) __FAST16 __STRINGIFY(x)
-#define __SCN16(x) __INT16 __STRINGIFY(x)
-#define __SCN16LEAST(x) __LEAST16 __STRINGIFY(x)
-#define __SCN16FAST(x) __FAST16 __STRINGIFY(x)
-
-
-#define PRId16		__PRI16(d)
-#define PRIi16		__PRI16(i)
-#define PRIo16		__PRI16(o)
-#define PRIu16		__PRI16(u)
-#define PRIx16		__PRI16(x)
-#define PRIX16		__PRI16(X)
-
-#define SCNd16		__SCN16(d)
-#define SCNi16		__SCN16(i)
-#define SCNo16		__SCN16(o)
-#define SCNu16		__SCN16(u)
-#define SCNx16		__SCN16(x)
-
-
-#define PRIdLEAST16	__PRI16LEAST(d)
-#define PRIiLEAST16	__PRI16LEAST(i)
-#define PRIoLEAST16	__PRI16LEAST(o)
-#define PRIuLEAST16	__PRI16LEAST(u)
-#define PRIxLEAST16	__PRI16LEAST(x)
-#define PRIXLEAST16	__PRI16LEAST(X)
-
-#define SCNdLEAST16	__SCN16LEAST(d)
-#define SCNiLEAST16	__SCN16LEAST(i)
-#define SCNoLEAST16	__SCN16LEAST(o)
-#define SCNuLEAST16	__SCN16LEAST(u)
-#define SCNxLEAST16	__SCN16LEAST(x)
-
-
-#define PRIdFAST16	__PRI16FAST(d)
-#define PRIiFAST16	__PRI16FAST(i)
-#define PRIoFAST16	__PRI16FAST(o)
-#define PRIuFAST16	__PRI16FAST(u)
-#define PRIxFAST16	__PRI16FAST(x)
-#define PRIXFAST16	__PRI16FAST(X)
-
-#define SCNdFAST16	__SCN16FAST(d)
-#define SCNiFAST16	__SCN16FAST(i)
-#define SCNoFAST16	__SCN16FAST(o)
-#define SCNuFAST16	__SCN16FAST(u)
-#define SCNxFAST16	__SCN16FAST(x)
-
-/* 32-bit types */
-#define __PRI32(x) __INT32 __STRINGIFY(x)
-#define __SCN32(x) __INT32 __STRINGIFY(x)
-#define __PRI32LEAST(x) __LEAST32 __STRINGIFY(x)
-#define __SCN32LEAST(x) __LEAST32 __STRINGIFY(x)
-#define __PRI32FAST(x) __FAST32 __STRINGIFY(x)
-#define __SCN32FAST(x) __FAST32 __STRINGIFY(x)
-
-#define PRId32		__PRI32(d)
-#define PRIi32		__PRI32(i)
-#define PRIo32		__PRI32(o)
-#define PRIu32		__PRI32(u)
-#define PRIx32		__PRI32(x)
-#define PRIX32		__PRI32(X)
-
-#define SCNd32		__SCN32(d)
-#define SCNi32		__SCN32(i)
-#define SCNo32		__SCN32(o)
-#define SCNu32		__SCN32(u)
-#define SCNx32		__SCN32(x)
-
-
-#define PRIdLEAST32	__PRI32LEAST(d)
-#define PRIiLEAST32	__PRI32LEAST(i)
-#define PRIoLEAST32	__PRI32LEAST(o)
-#define PRIuLEAST32	__PRI32LEAST(u)
-#define PRIxLEAST32	__PRI32LEAST(x)
-#define PRIXLEAST32	__PRI32LEAST(X)
-
-#define SCNdLEAST32	__SCN32LEAST(d)
-#define SCNiLEAST32	__SCN32LEAST(i)
-#define SCNoLEAST32	__SCN32LEAST(o)
-#define SCNuLEAST32	__SCN32LEAST(u)
-#define SCNxLEAST32	__SCN32LEAST(x)
-
-
-#define PRIdFAST32	__PRI32FAST(d)
-#define PRIiFAST32	__PRI32FAST(i)
-#define PRIoFAST32	__PRI32FAST(o)
-#define PRIuFAST32	__PRI32FAST(u)
-#define PRIxFAST32	__PRI32FAST(x)
-#define PRIXFAST32	__PRI32FAST(X)
-
-#define SCNdFAST32	__SCN32FAST(d)
-#define SCNiFAST32	__SCN32FAST(i)
-#define SCNoFAST32	__SCN32FAST(o)
-#define SCNuFAST32	__SCN32FAST(u)
-#define SCNxFAST32	__SCN32FAST(x)
-
-
-/* 64-bit types */
-#define __PRI64(x) __INT64 __STRINGIFY(x)
-#define __SCN64(x) __INT64 __STRINGIFY(x)
-
-#define __PRI64LEAST(x) __LEAST64 __STRINGIFY(x)
-#define __SCN64LEAST(x) __LEAST64 __STRINGIFY(x)
-#define __PRI64FAST(x) __FAST64 __STRINGIFY(x)
-#define __SCN64FAST(x) __FAST64 __STRINGIFY(x)
-
-#if __int64_t_defined
-#define PRId64		__PRI64(d)
-#define PRIi64		__PRI64(i)
-#define PRIo64		__PRI64(o)
-#define PRIu64		__PRI64(u)
-#define PRIx64		__PRI64(x)
-#define PRIX64		__PRI64(X)
-
-#define SCNd64		__SCN64(d)
-#define SCNi64		__SCN64(i)
-#define SCNo64		__SCN64(o)
-#define SCNu64		__SCN64(u)
-#define SCNx64		__SCN64(x)
-#endif
-
-#if __int_least64_t_defined
-#define PRIdLEAST64	__PRI64LEAST(d)
-#define PRIiLEAST64	__PRI64LEAST(i)
-#define PRIoLEAST64	__PRI64LEAST(o)
-#define PRIuLEAST64	__PRI64LEAST(u)
-#define PRIxLEAST64	__PRI64LEAST(x)
-#define PRIXLEAST64	__PRI64LEAST(X)
-
-#define SCNdLEAST64	__SCN64LEAST(d)
-#define SCNiLEAST64	__SCN64LEAST(i)
-#define SCNoLEAST64	__SCN64LEAST(o)
-#define SCNuLEAST64	__SCN64LEAST(u)
-#define SCNxLEAST64	__SCN64LEAST(x)
-#endif
-
-#if __int_fast64_t_defined
-#define PRIdFAST64	__PRI64FAST(d)
-#define PRIiFAST64	__PRI64FAST(i)
-#define PRIoFAST64	__PRI64FAST(o)
-#define PRIuFAST64	__PRI64FAST(u)
-#define PRIxFAST64	__PRI64FAST(x)
-#define PRIXFAST64	__PRI64FAST(X)
-
-#define SCNdFAST64	__SCN64FAST(d)
-#define SCNiFAST64	__SCN64FAST(i)
-#define SCNoFAST64	__SCN64FAST(o)
-#define SCNuFAST64	__SCN64FAST(u)
-#define SCNxFAST64	__SCN64FAST(x)
-#endif
-
-/* max-bit types */
-#if __have_long64
-#define __PRIMAX(x) __STRINGIFY(l##x)
-#define __SCNMAX(x) __STRINGIFY(l##x)
-#elif __have_longlong64
-#define __PRIMAX(x) __STRINGIFY(ll##x)
-#define __SCNMAX(x) __STRINGIFY(ll##x)
-#else
-#define __PRIMAX(x) __STRINGIFY(x)
-#define __SCNMAX(x) __STRINGIFY(x)
-#endif
-
-#define PRIdMAX		__PRIMAX(d)
-#define PRIiMAX		__PRIMAX(i)
-#define PRIoMAX		__PRIMAX(o)
-#define PRIuMAX		__PRIMAX(u)
-#define PRIxMAX		__PRIMAX(x)
-#define PRIXMAX		__PRIMAX(X)
-
-#define SCNdMAX		__SCNMAX(d)
-#define SCNiMAX		__SCNMAX(i)
-#define SCNoMAX		__SCNMAX(o)
-#define SCNuMAX		__SCNMAX(u)
-#define SCNxMAX		__SCNMAX(x)
-
-/* ptr types */
-#if defined (_INTPTR_EQ_LONGLONG)
-# define __PRIPTR(x) __STRINGIFY(ll##x)
-# define __SCNPTR(x) __STRINGIFY(ll##x)
-#elif defined (_INTPTR_EQ_LONG)
-# define __PRIPTR(x) __STRINGIFY(l##x)
-# define __SCNPTR(x) __STRINGIFY(l##x)
-#else
-# define __PRIPTR(x) __STRINGIFY(x)
-# define __SCNPTR(x) __STRINGIFY(x)
-#endif
-
-#define PRIdPTR		__PRIPTR(d)
-#define PRIiPTR		__PRIPTR(i)
-#define PRIoPTR		__PRIPTR(o)
-#define PRIuPTR		__PRIPTR(u)
-#define PRIxPTR		__PRIPTR(x)
-#define PRIXPTR		__PRIPTR(X)
-
-#define SCNdPTR		__SCNPTR(d)
-#define SCNiPTR		__SCNPTR(i)
-#define SCNoPTR		__SCNPTR(o)
-#define SCNuPTR		__SCNPTR(u)
-#define SCNxPTR		__SCNPTR(x)
-
-
-typedef struct {
-  intmax_t	quot;
-  intmax_t	rem;
-} imaxdiv_t;
-
-struct _reent;
-
-#ifdef __cplusplus
-extern "C" {
-#endif
-
-extern intmax_t  imaxabs(intmax_t j);
-extern imaxdiv_t imaxdiv(intmax_t numer, intmax_t denomer);
-extern intmax_t  strtoimax(const char *__restrict, char **__restrict, int);
-extern intmax_t  _strtoimax_r(struct _reent *, const char *__restrict, char **__restrict, int);
-extern uintmax_t strtoumax(const char *__restrict, char **__restrict, int);
-extern uintmax_t _strtoumax_r(struct _reent *, const char *__restrict, char **__restrict, int);
-extern intmax_t  wcstoimax(const wchar_t *__restrict, wchar_t **__restrict, int);
-extern intmax_t  _wcstoimax_r(struct _reent *, const wchar_t *__restrict, wchar_t **__restrict, int);
-extern uintmax_t wcstoumax(const wchar_t *__restrict, wchar_t **__restrict, int);
-extern uintmax_t _wcstoumax_r(struct _reent *, const wchar_t *__restrict, wchar_t **__restrict, int);
-
-#if __BSD_VISIBLE
-extern intmax_t  strtoimax_l(const char *__restrict, char **_restrict, int, locale_t);
-extern uintmax_t strtoumax_l(const char *__restrict, char **_restrict, int, locale_t);
-extern intmax_t  wcstoimax_l(const wchar_t *__restrict, wchar_t **_restrict, int, locale_t);
-extern uintmax_t wcstoumax_l(const wchar_t *__restrict, wchar_t **_restrict, int, locale_t);
-#endif
-
-#ifdef __cplusplus
-}
-#endif
-
-#endif

src/include/machine/_default_types.h

@@ -1,250 +0,0 @@
-/*
- *  $Id$
- */
-
-#ifndef _MACHINE__DEFAULT_TYPES_H
-#define _MACHINE__DEFAULT_TYPES_H
-
-#include <sys/features.h>
-
-/*
- * Guess on types by examining *_MIN / *_MAX defines.
- */
-#if __GNUC_PREREQ (3, 3)
-/* GCC >= 3.3.0 has __<val>__ implicitly defined. */
-#define __EXP(x) __##x##__
-#else
-/* Fall back to POSIX versions from <limits.h> */
-#define __EXP(x) x
-#include <limits.h>
-#endif
-
-/* Check if "long long" is 64bit wide */
-/* Modern GCCs provide __LONG_LONG_MAX__, SUSv3 wants LLONG_MAX */
-#if ( defined(__LONG_LONG_MAX__) && (__LONG_LONG_MAX__ > 0x7fffffff) ) \
-  || ( defined(LLONG_MAX) && (LLONG_MAX > 0x7fffffff) )
-#define __have_longlong64 1
-#endif
-
-/* Check if "long" is 64bit or 32bit wide */
-#if __EXP(LONG_MAX) > 0x7fffffff
-#define __have_long64 1
-#elif __EXP(LONG_MAX) == 0x7fffffff && !defined(__SPU__)
-#define __have_long32 1
-#endif
-
-#ifdef __cplusplus
-extern "C" {
-#endif
-
-#ifdef __INT8_TYPE__
-typedef __INT8_TYPE__ __int8_t;
-#ifdef __UINT8_TYPE__
-typedef __UINT8_TYPE__ __uint8_t;
-#else
-typedef unsigned __INT8_TYPE__ __uint8_t;
-#endif
-#define ___int8_t_defined 1
-#elif __EXP(SCHAR_MAX) == 0x7f
-typedef signed char __int8_t ;
-typedef unsigned char __uint8_t ;
-#define ___int8_t_defined 1
-#endif
-
-#ifdef __INT16_TYPE__
-typedef __INT16_TYPE__ __int16_t;
-#ifdef __UINT16_TYPE__
-typedef __UINT16_TYPE__ __uint16_t;
-#else
-typedef unsigned __INT16_TYPE__ __uint16_t;
-#endif
-#define ___int16_t_defined 1
-#elif __EXP(INT_MAX) == 0x7fff
-typedef signed int __int16_t;
-typedef unsigned int __uint16_t;
-#define ___int16_t_defined 1
-#elif __EXP(SHRT_MAX) == 0x7fff
-typedef signed short __int16_t;
-typedef unsigned short __uint16_t;
-#define ___int16_t_defined 1
-#elif __EXP(SCHAR_MAX) == 0x7fff
-typedef signed char __int16_t;
-typedef unsigned char __uint16_t;
-#define ___int16_t_defined 1
-#endif
-
-#ifdef __INT32_TYPE__
-typedef __INT32_TYPE__ __int32_t;
-#ifdef __UINT32_TYPE__
-typedef __UINT32_TYPE__ __uint32_t;
-#else
-typedef unsigned __INT32_TYPE__ __uint32_t;
-#endif
-#define ___int32_t_defined 1
-#elif __EXP(INT_MAX) == 0x7fffffffL
-typedef signed int __int32_t;
-typedef unsigned int __uint32_t;
-#define ___int32_t_defined 1
-#elif __EXP(LONG_MAX) == 0x7fffffffL
-typedef signed long __int32_t;
-typedef unsigned long __uint32_t;
-#define ___int32_t_defined 1
-#elif __EXP(SHRT_MAX) == 0x7fffffffL
-typedef signed short __int32_t;
-typedef unsigned short __uint32_t;
-#define ___int32_t_defined 1
-#elif __EXP(SCHAR_MAX) == 0x7fffffffL
-typedef signed char __int32_t;
-typedef unsigned char __uint32_t;
-#define ___int32_t_defined 1
-#endif
-
-#ifdef __INT64_TYPE__
-typedef __INT64_TYPE__ __int64_t;
-#ifdef __UINT64_TYPE__
-typedef __UINT64_TYPE__ __uint64_t;
-#else
-typedef unsigned __INT64_TYPE__ __uint64_t;
-#endif
-#define ___int64_t_defined 1
-#elif __EXP(LONG_MAX) > 0x7fffffff
-typedef signed long __int64_t;
-typedef unsigned long __uint64_t;
-#define ___int64_t_defined 1
-
-/* GCC has __LONG_LONG_MAX__ */
-#elif  defined(__LONG_LONG_MAX__) && (__LONG_LONG_MAX__ > 0x7fffffff)
-typedef signed long long __int64_t;
-typedef unsigned long long __uint64_t;
-#define ___int64_t_defined 1
-
-/* POSIX mandates LLONG_MAX in <limits.h> */
-#elif  defined(LLONG_MAX) && (LLONG_MAX > 0x7fffffff)
-typedef signed long long __int64_t;
-typedef unsigned long long __uint64_t;
-#define ___int64_t_defined 1
-
-#elif  __EXP(INT_MAX) > 0x7fffffff
-typedef signed int __int64_t;
-typedef unsigned int __uint64_t;
-#define ___int64_t_defined 1
-#endif
-
-#ifdef __INT_LEAST8_TYPE__
-typedef __INT_LEAST8_TYPE__ __int_least8_t;
-#ifdef __UINT_LEAST8_TYPE__
-typedef __UINT_LEAST8_TYPE__ __uint_least8_t;
-#else
-typedef unsigned __INT_LEAST8_TYPE__ __uint_least8_t;
-#endif
-#define ___int_least8_t_defined 1
-#elif defined(___int8_t_defined)
-typedef __int8_t __int_least8_t;
-typedef __uint8_t __uint_least8_t;
-#define ___int_least8_t_defined 1
-#elif defined(___int16_t_defined)
-typedef __int16_t __int_least8_t;
-typedef __uint16_t __uint_least8_t;
-#define ___int_least8_t_defined 1
-#elif defined(___int32_t_defined)
-typedef __int32_t __int_least8_t;
-typedef __uint32_t __uint_least8_t;
-#define ___int_least8_t_defined 1
-#elif defined(___int64_t_defined)
-typedef __int64_t __int_least8_t;
-typedef __uint64_t __uint_least8_t;
-#define ___int_least8_t_defined 1
-#endif
-
-#ifdef __INT_LEAST16_TYPE__
-typedef __INT_LEAST16_TYPE__ __int_least16_t;
-#ifdef __UINT_LEAST16_TYPE__
-typedef __UINT_LEAST16_TYPE__ __uint_least16_t;
-#else
-typedef unsigned __INT_LEAST16_TYPE__ __uint_least16_t;
-#endif
-#define ___int_least16_t_defined 1
-#elif defined(___int16_t_defined)
-typedef __int16_t __int_least16_t;
-typedef __uint16_t __uint_least16_t;
-#define ___int_least16_t_defined 1
-#elif defined(___int32_t_defined)
-typedef __int32_t __int_least16_t;
-typedef __uint32_t __uint_least16_t;
-#define ___int_least16_t_defined 1
-#elif defined(___int64_t_defined)
-typedef __int64_t __int_least16_t;
-typedef __uint64_t __uint_least16_t;
-#define ___int_least16_t_defined 1
-#endif
-
-#ifdef __INT_LEAST32_TYPE__
-typedef __INT_LEAST32_TYPE__ __int_least32_t;
-#ifdef __UINT_LEAST32_TYPE__
-typedef __UINT_LEAST32_TYPE__ __uint_least32_t;
-#else
-typedef unsigned __INT_LEAST32_TYPE__ __uint_least32_t;
-#endif
-#define ___int_least32_t_defined 1
-#elif defined(___int32_t_defined)
-typedef __int32_t __int_least32_t;
-typedef __uint32_t __uint_least32_t;
-#define ___int_least32_t_defined 1
-#elif defined(___int64_t_defined)
-typedef __int64_t __int_least32_t;
-typedef __uint64_t __uint_least32_t;
-#define ___int_least32_t_defined 1
-#endif
-
-#ifdef __INT_LEAST64_TYPE__
-typedef __INT_LEAST64_TYPE__ __int_least64_t;
-#ifdef __UINT_LEAST64_TYPE__
-typedef __UINT_LEAST64_TYPE__ __uint_least64_t;
-#else
-typedef unsigned __INT_LEAST64_TYPE__ __uint_least64_t;
-#endif
-#define ___int_least64_t_defined 1
-#elif defined(___int64_t_defined)
-typedef __int64_t __int_least64_t;
-typedef __uint64_t __uint_least64_t;
-#define ___int_least64_t_defined 1
-#endif
-
-#if defined(__INTMAX_TYPE__)
-typedef __INTMAX_TYPE__ __intmax_t;
-#elif __have_longlong64
-typedef signed long long __intmax_t;
-#else
-typedef signed long __intmax_t;
-#endif
-
-#if defined(__UINTMAX_TYPE__)
-typedef __UINTMAX_TYPE__ __uintmax_t;
-#elif __have_longlong64
-typedef unsigned long long __uintmax_t;
-#else
-typedef unsigned long __uintmax_t;
-#endif
-
-#ifdef __INTPTR_TYPE__
-typedef __INTPTR_TYPE__ __intptr_t;
-#ifdef __UINTPTR_TYPE__
-typedef __UINTPTR_TYPE__ __uintptr_t;
-#else
-typedef unsigned __INTPTR_TYPE__ __uintptr_t;
-#endif
-#elif defined(__PTRDIFF_TYPE__)
-typedef __PTRDIFF_TYPE__ __intptr_t;
-typedef unsigned __PTRDIFF_TYPE__ __uintptr_t;
-#else
-typedef long __intptr_t;
-typedef unsigned long __uintptr_t;
-#endif
-
-#undef __EXP
-
-#ifdef __cplusplus
-}
-#endif
-
-#endif /* _MACHINE__DEFAULT_TYPES_H */

src/include/machine/_endian.h

@@ -1,39 +0,0 @@
-/* ARM configuration file.
-   Copyright (c) 2015 ARM Ltd.  All rights reserved.
-
-   Redistribution and use in source and binary forms, with or without
-   modification, are permitted provided that the following conditions
-   are met:
-   1. Redistributions of source code must retain the above copyright
-      notice, this list of conditions and the following disclaimer.
-   2. Redistributions in binary form must reproduce the above copyright
-      notice, this list of conditions and the following disclaimer in the
-      documentation and/or other materials provided with the distribution.
-   3. The name of the company may not be used to endorse or promote
-      products derived from this software without specific prior written
-      permission.
-
-   THIS SOFTWARE IS PROVIDED BY ARM LTD ``AS IS'' AND ANY EXPRESS OR IMPLIED
-   WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
-   MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
-   IN NO EVENT SHALL ARM LTD BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
-   SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED
-   TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
-   PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
-   LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
-   NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
-   SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. */
-
-#ifndef __MACHINE_ENDIAN_H__
-#error "must be included via <machine/endian.h>"
-#endif /* !__MACHINE_ENDIAN_H__ */
-
-#define	_LITTLE_ENDIAN	1234
-#define	_BIG_ENDIAN	4321
-#define	_PDP_ENDIAN	3412
-
-#ifdef __ARMEB__
-#define	_BYTE_ORDER	_BIG_ENDIAN
-#else
-#define	_BYTE_ORDER	_LITTLE_ENDIAN
-#endif

src/include/machine/_types.h

@@ -1,8 +0,0 @@
-/*
- *  $Id$
- */
-
-#ifndef _MACHINE__TYPES_H
-#define _MACHINE__TYPES_H
-#include <machine/_default_types.h>
-#endif

src/include/machine/endian.h

@@ -1,69 +0,0 @@
-#ifndef __MACHINE_ENDIAN_H__
-#define	__MACHINE_ENDIAN_H__
-
-#include <sys/cdefs.h>
-#include <sys/_types.h>
-#include <machine/_endian.h>
-
-#if _BYTE_ORDER == _LITTLE_ENDIAN
-#define	_QUAD_HIGHWORD	1
-#define	_QUAD_LOWWORD	0
-#else
-#define	_QUAD_HIGHWORD	0
-#define	_QUAD_LOWWORD	1
-#endif
-
-#if __BSD_VISIBLE
-#define	LITTLE_ENDIAN	_LITTLE_ENDIAN
-#define	BIG_ENDIAN	_BIG_ENDIAN
-#define	PDP_ENDIAN	_PDP_ENDIAN
-#define	BYTE_ORDER	_BYTE_ORDER
-#endif
-
-#ifdef __GNUC__
-#define	__bswap16(_x)	__builtin_bswap16(_x)
-#define	__bswap32(_x)	__builtin_bswap32(_x)
-#define	__bswap64(_x)	__builtin_bswap64(_x)
-#else /* __GNUC__ */
-static __inline __uint16_t
-__bswap16(__uint16_t _x)
-{
-
-	return ((__uint16_t)((_x >> 8) | ((_x << 8) & 0xff00)));
-}
-
-static __inline __uint32_t
-__bswap32(__uint32_t _x)
-{
-
-	return ((__uint32_t)((_x >> 24) | ((_x >> 8) & 0xff00) |
-	    ((_x << 8) & 0xff0000) | ((_x << 24) & 0xff000000)));
-}
-
-static __inline __uint64_t
-__bswap64(__uint64_t _x)
-{
-
-	return ((__uint64_t)((_x >> 56) | ((_x >> 40) & 0xff00) |
-	    ((_x >> 24) & 0xff0000) | ((_x >> 8) & 0xff000000) |
-	    ((_x << 8) & ((__uint64_t)0xff << 32)) |
-	    ((_x << 24) & ((__uint64_t)0xff << 40)) |
-	    ((_x << 40) & ((__uint64_t)0xff << 48)) | ((_x << 56))));
-}
-#endif /* !__GNUC__ */
-
-#ifndef __machine_host_to_from_network_defined
-#if _BYTE_ORDER == _LITTLE_ENDIAN
-#define	__htonl(_x)	__bswap32(_x)
-#define	__htons(_x)	__bswap16(_x)
-#define	__ntohl(_x)	__bswap32(_x)
-#define	__ntohs(_x)	__bswap16(_x)
-#else
-#define	__htonl(_x)	((__uint32_t)(_x))
-#define	__htons(_x)	((__uint16_t)(_x))
-#define	__ntohl(_x)	((__uint32_t)(_x))
-#define	__ntohs(_x)	((__uint16_t)(_x))
-#endif
-#endif /* __machine_host_to_from_network_defined */
-
-#endif /* __MACHINE_ENDIAN_H__ */

src/include/machine/ieeefp.h

@@ -1,475 +0,0 @@
-#ifndef __IEEE_BIG_ENDIAN
-#ifndef __IEEE_LITTLE_ENDIAN
-
-/* This file can define macros to choose variations of the IEEE float
-   format:
-
-   _FLT_LARGEST_EXPONENT_IS_NORMAL
-
-	Defined if the float format uses the largest exponent for finite
-	numbers rather than NaN and infinity representations.  Such a
-	format cannot represent NaNs or infinities at all, but it's FLT_MAX
-	is twice the IEEE value.
-
-   _FLT_NO_DENORMALS
-
-	Defined if the float format does not support IEEE denormals.  Every
-	float with a zero exponent is taken to be a zero representation.
- 
-   ??? At the moment, there are no equivalent macros above for doubles and
-   the macros are not fully supported by --enable-newlib-hw-fp.
-
-   __IEEE_BIG_ENDIAN
-
-        Defined if the float format is big endian.  This is mutually exclusive
-        with __IEEE_LITTLE_ENDIAN.
-
-   __IEEE_LITTLE_ENDIAN
- 
-        Defined if the float format is little endian.  This is mutually exclusive
-        with __IEEE_BIG_ENDIAN.
-
-   Note that one of __IEEE_BIG_ENDIAN or __IEEE_LITTLE_ENDIAN must be specified for a
-   platform or error will occur.
-
-   __IEEE_BYTES_LITTLE_ENDIAN
-
-        This flag is used in conjunction with __IEEE_BIG_ENDIAN to describe a situation 
-	whereby multiple words of an IEEE floating point are in big endian order, but the
-	words themselves are little endian with respect to the bytes.
-
-   _DOUBLE_IS_32BITS 
-
-        This is used on platforms that support double by using the 32-bit IEEE
-        float type.
-
-   _FLOAT_ARG
-
-        This represents what type a float arg is passed as.  It is used when the type is
-        not promoted to double.
-	
-
-   __OBSOLETE_MATH_DEFAULT
-
-	Default value for __OBSOLETE_MATH if that's not set by the user.
-	It should be set here based on predefined feature macros.
-
-   __OBSOLETE_MATH
-
-	If set to 1 then some new math code will be disabled and older libm
-	code will be used instead.  This is necessary because the new math
-	code does not support all targets, it assumes that the toolchain has
-	ISO C99 support (hexfloat literals, standard fenv semantics), the
-	target has IEEE-754 conforming binary32 float and binary64 double
-	(not mixed endian) representation, standard SNaN representation,
-	double and single precision arithmetics has similar latency and it
-	has no legacy SVID matherr support, only POSIX errno and fenv
-	exception based error handling.
-*/
-
-#if (defined(__arm__) || defined(__thumb__)) && !defined(__MAVERICK__)
-/* ARM traditionally used big-endian words; and within those words the
-   byte ordering was big or little endian depending upon the target.
-   Modern floating-point formats are naturally ordered; in this case
-   __VFP_FP__ will be defined, even if soft-float.  */
-#ifdef __VFP_FP__
-# ifdef __ARMEL__
-#  define __IEEE_LITTLE_ENDIAN
-# else
-#  define __IEEE_BIG_ENDIAN
-# endif
-# if __ARM_FP & 0x8
-#  define __OBSOLETE_MATH_DEFAULT 0
-# endif
-#else
-# define __IEEE_BIG_ENDIAN
-# ifdef __ARMEL__
-#  define __IEEE_BYTES_LITTLE_ENDIAN
-# endif
-#endif
-#endif
-
-#if defined (__aarch64__)
-#if defined (__AARCH64EL__)
-#define __IEEE_LITTLE_ENDIAN
-#else
-#define __IEEE_BIG_ENDIAN
-#endif
-#define __OBSOLETE_MATH_DEFAULT 0
-#endif
-
-#ifdef __epiphany__
-#define __IEEE_LITTLE_ENDIAN
-#define Sudden_Underflow 1
-#endif
-
-#ifdef __hppa__
-#define __IEEE_BIG_ENDIAN
-#endif
-
-#ifdef __nds32__
-#ifdef __big_endian__
-#define __IEEE_BIG_ENDIAN
-#else
-#define __IEEE_LITTLE_ENDIAN
-#endif
-#endif
-
-#ifdef __SPU__
-#define __IEEE_BIG_ENDIAN
-
-#define isfinite(__y) \
-	(__extension__ ({int __cy; \
-		(sizeof (__y) == sizeof (float))  ? (1) : \
-		(__cy = fpclassify(__y)) != FP_INFINITE && __cy != FP_NAN;}))
-
-#define isinf(__x) ((sizeof (__x) == sizeof (float))  ?  (0) : __isinfd(__x))
-#define isnan(__x) ((sizeof (__x) == sizeof (float))  ?  (0) : __isnand(__x))
-
-/*
- * Macros for use in ieeefp.h. We can't just define the real ones here
- * (like those above) as we have name space issues when this is *not*
- * included via generic the ieeefp.h.
- */
-#define __ieeefp_isnanf(x)	0
-#define __ieeefp_isinff(x)	0
-#define __ieeefp_finitef(x)	1
-#endif
-
-#ifdef __sparc__
-#ifdef __LITTLE_ENDIAN_DATA__
-#define __IEEE_LITTLE_ENDIAN
-#else
-#define __IEEE_BIG_ENDIAN
-#endif
-#endif
-
-#if defined(__m68k__) || defined(__mc68000__)
-#define __IEEE_BIG_ENDIAN
-#endif
-
-#if defined(__mc68hc11__) || defined(__mc68hc12__) || defined(__mc68hc1x__)
-#define __IEEE_BIG_ENDIAN
-#ifdef __HAVE_SHORT_DOUBLE__
-# define _DOUBLE_IS_32BITS
-#endif
-#endif
-
-#if defined (__H8300__) || defined (__H8300H__) || defined (__H8300S__) || defined (__H8500__) || defined (__H8300SX__)
-#define __IEEE_BIG_ENDIAN
-#define _FLOAT_ARG float
-#define _DOUBLE_IS_32BITS
-#endif
-
-#if defined (__xc16x__) || defined (__xc16xL__) || defined (__xc16xS__)
-#define __IEEE_LITTLE_ENDIAN
-#define _FLOAT_ARG float
-#define _DOUBLE_IS_32BITS
-#endif
-
-
-#ifdef __sh__
-#ifdef __LITTLE_ENDIAN__
-#define __IEEE_LITTLE_ENDIAN
-#else
-#define __IEEE_BIG_ENDIAN
-#endif
-#if defined(__SH2E__) || defined(__SH3E__) || defined(__SH4_SINGLE_ONLY__) || defined(__SH2A_SINGLE_ONLY__)
-#define _DOUBLE_IS_32BITS
-#endif
-#endif
-
-#ifdef _AM29K
-#define __IEEE_BIG_ENDIAN
-#endif
-
-#ifdef _WIN32
-#define __IEEE_LITTLE_ENDIAN
-#endif
-
-#ifdef __i386__
-#define __IEEE_LITTLE_ENDIAN
-#endif
-
-#ifdef __riscv
-#define __IEEE_LITTLE_ENDIAN
-#endif
-
-#ifdef __i960__
-#define __IEEE_LITTLE_ENDIAN
-#endif
-
-#ifdef __lm32__
-#define __IEEE_BIG_ENDIAN
-#endif
-
-#ifdef __M32R__
-#define __IEEE_BIG_ENDIAN
-#endif
-
-#ifdef __nvptx__
-#define __IEEE_LITTLE_ENDIAN
-#endif
-
-#if defined(_C4x) || defined(_C3x)
-#define __IEEE_BIG_ENDIAN
-#define _DOUBLE_IS_32BITS
-#endif
-
-#ifdef __TMS320C6X__
-#ifdef _BIG_ENDIAN
-#define __IEEE_BIG_ENDIAN
-#else
-#define __IEEE_LITTLE_ENDIAN
-#endif
-#endif
-
-#ifdef __TIC80__
-#define __IEEE_LITTLE_ENDIAN
-#endif
-
-#ifdef __MIPSEL__
-#define __IEEE_LITTLE_ENDIAN
-#endif
-#ifdef __MIPSEB__
-#define __IEEE_BIG_ENDIAN
-#endif
-
-#ifdef __MMIX__
-#define __IEEE_BIG_ENDIAN
-#endif
-
-#ifdef __D30V__
-#define __IEEE_BIG_ENDIAN
-#endif
-
-/* necv70 was __IEEE_LITTLE_ENDIAN. */
-
-#ifdef __W65__
-#define __IEEE_LITTLE_ENDIAN
-#define _DOUBLE_IS_32BITS
-#endif
-
-#if defined(__Z8001__) || defined(__Z8002__)
-#define __IEEE_BIG_ENDIAN
-#endif
-
-#ifdef __m88k__
-#define __IEEE_BIG_ENDIAN
-#endif
-
-#ifdef __mn10300__
-#define __IEEE_LITTLE_ENDIAN
-#endif
-
-#ifdef __mn10200__
-#define __IEEE_LITTLE_ENDIAN
-#define _DOUBLE_IS_32BITS
-#endif
-
-#ifdef __v800
-#define __IEEE_LITTLE_ENDIAN
-#endif
-
-#ifdef __v850
-#define __IEEE_LITTLE_ENDIAN
-#endif
-
-#ifdef __D10V__
-#define __IEEE_BIG_ENDIAN
-#if __DOUBLE__ == 32
-#define _DOUBLE_IS_32BITS
-#endif
-#endif
-
-#ifdef __PPC__
-#if (defined(_BIG_ENDIAN) && _BIG_ENDIAN) || (defined(_AIX) && _AIX)
-#define __IEEE_BIG_ENDIAN
-#else
-#if (defined(_LITTLE_ENDIAN) && _LITTLE_ENDIAN) || (defined(__sun__) && __sun__) || (defined(_WIN32) && _WIN32)
-#define __IEEE_LITTLE_ENDIAN
-#endif
-#endif
-#endif
-
-#ifdef __xstormy16__
-#define __IEEE_LITTLE_ENDIAN
-#endif
-
-#ifdef __arc__
-#ifdef __big_endian__
-#define __IEEE_BIG_ENDIAN
-#else
-#define __IEEE_LITTLE_ENDIAN
-#endif
-#endif
-
-#ifdef __CRX__
-#define __IEEE_LITTLE_ENDIAN
-#endif
-
-#ifdef __fr30__
-#define __IEEE_BIG_ENDIAN
-#endif
-
-#ifdef __FT32__
-#define __IEEE_LITTLE_ENDIAN
-#endif
-
-#ifdef __mcore__
-#define __IEEE_BIG_ENDIAN
-#endif
-
-#ifdef __mt__
-#define __IEEE_BIG_ENDIAN
-#endif
-
-#ifdef __frv__
-#define __IEEE_BIG_ENDIAN
-#endif
-
-#ifdef __moxie__
-#ifdef __MOXIE_BIG_ENDIAN__
-#define __IEEE_BIG_ENDIAN
-#else
-#define __IEEE_LITTLE_ENDIAN
-#endif
-#endif
-
-#ifdef __ia64__
-#ifdef __BIG_ENDIAN__
-#define __IEEE_BIG_ENDIAN
-#else
-#define __IEEE_LITTLE_ENDIAN
-#endif
-#endif
-
-#ifdef __AVR__
-#define __IEEE_LITTLE_ENDIAN
-#define _DOUBLE_IS_32BITS
-#endif
-
-#if defined(__or1k__) || defined(__OR1K__) || defined(__OR1KND__)
-#define __IEEE_BIG_ENDIAN
-#endif
-
-#ifdef __IP2K__
-#define __IEEE_BIG_ENDIAN
-#define __SMALL_BITFIELDS
-#define _DOUBLE_IS_32BITS
-#endif
-
-#ifdef __iq2000__
-#define __IEEE_BIG_ENDIAN
-#endif
-
-#ifdef __MAVERICK__
-#ifdef __ARMEL__
-#  define __IEEE_LITTLE_ENDIAN
-#else  /* must be __ARMEB__ */
-#  define __IEEE_BIG_ENDIAN
-#endif /* __ARMEL__ */
-#endif /* __MAVERICK__ */
-
-#ifdef __m32c__
-#define __IEEE_LITTLE_ENDIAN
-#define __SMALL_BITFIELDS
-#endif
-
-#ifdef __CRIS__
-#define __IEEE_LITTLE_ENDIAN
-#endif
-
-#ifdef __BFIN__
-#define __IEEE_LITTLE_ENDIAN
-#endif
-
-#ifdef __x86_64__
-#define __IEEE_LITTLE_ENDIAN
-#endif
-
-#ifdef __mep__
-#ifdef __LITTLE_ENDIAN__
-#define __IEEE_LITTLE_ENDIAN
-#else
-#define __IEEE_BIG_ENDIAN
-#endif
-#endif
-
-#ifdef __MICROBLAZE__
-#ifndef __MICROBLAZEEL__
-#define __IEEE_BIG_ENDIAN
-#else
-#define __IEEE_LITTLE_ENDIAN
-#endif
-#endif
-
-#ifdef __MSP430__
-#define __IEEE_LITTLE_ENDIAN
-#define __SMALL_BITFIELDS	/* 16 Bit INT */
-#endif
-
-#ifdef __RL78__
-#define __IEEE_LITTLE_ENDIAN
-#define __SMALL_BITFIELDS	/* 16 Bit INT */
-#ifndef __RL78_64BIT_DOUBLES__
-#define _DOUBLE_IS_32BITS
-#endif
-#endif
-
-#ifdef __RX__
-
-#ifdef __RX_BIG_ENDIAN__
-#define __IEEE_BIG_ENDIAN
-#else
-#define __IEEE_LITTLE_ENDIAN
-#endif
-
-#ifndef __RX_64BIT_DOUBLES__
-#define _DOUBLE_IS_32BITS
-#endif
-
-#ifdef __RX_16BIT_INTS__
-#define __SMALL_BITFIELDS
-#endif
-
-#endif
-
-#if (defined(__CR16__) || defined(__CR16C__) ||defined(__CR16CP__))
-#define __IEEE_LITTLE_ENDIAN
-#define __SMALL_BITFIELDS	/* 16 Bit INT */
-#endif
-
-#ifdef __NIOS2__
-# ifdef __nios2_big_endian__
-#  define __IEEE_BIG_ENDIAN
-# else
-#  define __IEEE_LITTLE_ENDIAN
-# endif
-#endif
-
-#ifdef __VISIUM__
-#define __IEEE_BIG_ENDIAN
-#endif
-
-#ifdef __CYGWIN__
-#define __OBSOLETE_MATH_DEFAULT 0
-#endif
-
-#ifndef __OBSOLETE_MATH_DEFAULT
-/* Use old math code by default.  */
-#define __OBSOLETE_MATH_DEFAULT 1
-#endif
-#ifndef __OBSOLETE_MATH
-#define __OBSOLETE_MATH __OBSOLETE_MATH_DEFAULT
-#endif
-
-#ifndef __IEEE_BIG_ENDIAN
-#ifndef __IEEE_LITTLE_ENDIAN
-#error Endianess not declared!!
-#endif /* not __IEEE_LITTLE_ENDIAN */
-#endif /* not __IEEE_BIG_ENDIAN */
-
-#endif /* not __IEEE_LITTLE_ENDIAN */
-#endif /* not __IEEE_BIG_ENDIAN */
-

src/include/machine/stdlib.h

@@ -1,8 +0,0 @@
-#ifndef	_MACHSTDLIB_H_
-#define	_MACHSTDLIB_H_
-
-/* place holder so platforms may add stdlib.h extensions */
-
-#endif	/* _MACHSTDLIB_H_ */
-
-

src/include/machine/types.h

@@ -1,7 +0,0 @@
-/*
- * Newlib targets may provide an own version of this file in their machine
- * directory to add custom user types for <sys/types.h>.
- */
-#ifndef _SYS_TYPES_H
-#error "must be included via <sys/types.h>"
-#endif /* !_SYS_TYPES_H */

src/include/newlib.h

@@ -1,206 +0,0 @@
-/* newlib.h.  Generated from newlib.hin by configure.  */
-/* newlib.hin.  Manually edited from the output of autoheader to
-   remove all PACKAGE_ macros which will collide with any user
-   package using newlib header files and having its own package name,
-   version, etc...  */
-#ifndef __NEWLIB_H__
-
-#define __NEWLIB_H__ 1
-
-/* EL/IX level */
-/* #undef _ELIX_LEVEL */
-
-/* Newlib version */
-#include <_newlib_version.h>
-
-/* C99 formats support (such as %a, %zu, ...) in IO functions like
- * printf/scanf enabled */
-#define _WANT_IO_C99_FORMATS 1
-
-/* long long type support in IO functions like printf/scanf enabled */
-#define _WANT_IO_LONG_LONG 1
-
-/* Register application finalization function using atexit. */
-#define _WANT_REGISTER_FINI 1
-
-/* long double type support in IO functions like printf/scanf enabled */
-/* #undef _WANT_IO_LONG_DOUBLE */
-
-/* Positional argument support in printf functions enabled.  */
-/* #undef _WANT_IO_POS_ARGS */
-
-/* Optional reentrant struct support.  Used mostly on platforms with
-   very restricted storage.  */
-/* #undef _WANT_REENT_SMALL */
-
-/* Multibyte supported */
-/* #undef _MB_CAPABLE */
-
-/* MB_LEN_MAX */
-#define _MB_LEN_MAX 1
-
-/* ICONV enabled */
-/* #undef _ICONV_ENABLED */
-
-/* Enable ICONV external CCS files loading capabilities */
-/* #undef _ICONV_ENABLE_EXTERNAL_CCS */
-
-/* Define if the linker supports .preinit_array/.init_array/.fini_array
- * sections.  */
-#define HAVE_INITFINI_ARRAY 1
-
-/* True if atexit() may dynamically allocate space for cleanup
-   functions.  */
-#define _ATEXIT_DYNAMIC_ALLOC 1
-
-/* True if long double supported.  */
-#define _HAVE_LONG_DOUBLE 1
-
-/* Define if compiler supports -fno-tree-loop-distribute-patterns. */
-#define _HAVE_CC_INHIBIT_LOOP_TO_LIBCALL 1
-
-/* True if long double supported and it is equal to double.  */
-#define _LDBL_EQ_DBL 1
- 
-/* Define if ivo supported in streamio.  */
-#define _FVWRITE_IN_STREAMIO 1
-
-/* Define if fseek functions support seek optimization.  */
-#define _FSEEK_OPTIMIZATION 1
-
-/* Define if wide char orientation is supported.  */
-#define _WIDE_ORIENT 1
-
-/* Define if unbuffered stream file optimization is supported.  */
-#define _UNBUF_STREAM_OPT 1
-
-/* Define if lite version of exit supported.  */
-/* #undef _LITE_EXIT */
-
-/* Define if declare atexit data as global.  */
-/* #undef _REENT_GLOBAL_ATEXIT */
-
-/* Define to move the stdio stream FILE objects out of struct _reent and make
-   them global.  The stdio stream pointers of struct _reent are initialized to
-   point to the global stdio FILE stream objects. */
-/* #undef _WANT_REENT_GLOBAL_STDIO_STREAMS */
-
-/* Define if small footprint nano-formatted-IO implementation used.  */
-/* #undef _NANO_FORMATTED_IO */
-
-/* Define if using retargetable functions for default lock routines.  */
-#define _RETARGETABLE_LOCKING 1
-
-/* Define to use type long for time_t.  */
-/* #undef _WANT_USE_LONG_TIME_T */
-
-/*
- * Iconv encodings enabled ("to" direction)
- */
-/* #undef _ICONV_TO_ENCODING_BIG5 */
-/* #undef _ICONV_TO_ENCODING_CP775 */
-/* #undef _ICONV_TO_ENCODING_CP850 */
-/* #undef _ICONV_TO_ENCODING_CP852 */
-/* #undef _ICONV_TO_ENCODING_CP855 */
-/* #undef _ICONV_TO_ENCODING_CP866 */
-/* #undef _ICONV_TO_ENCODING_EUC_JP */
-/* #undef _ICONV_TO_ENCODING_EUC_TW */
-/* #undef _ICONV_TO_ENCODING_EUC_KR */
-/* #undef _ICONV_TO_ENCODING_ISO_8859_1 */
-/* #undef _ICONV_TO_ENCODING_ISO_8859_10 */
-/* #undef _ICONV_TO_ENCODING_ISO_8859_11 */
-/* #undef _ICONV_TO_ENCODING_ISO_8859_13 */
-/* #undef _ICONV_TO_ENCODING_ISO_8859_14 */
-/* #undef _ICONV_TO_ENCODING_ISO_8859_15 */
-/* #undef _ICONV_TO_ENCODING_ISO_8859_2 */
-/* #undef _ICONV_TO_ENCODING_ISO_8859_3 */
-/* #undef _ICONV_TO_ENCODING_ISO_8859_4 */
-/* #undef _ICONV_TO_ENCODING_ISO_8859_5 */
-/* #undef _ICONV_TO_ENCODING_ISO_8859_6 */
-/* #undef _ICONV_TO_ENCODING_ISO_8859_7 */
-/* #undef _ICONV_TO_ENCODING_ISO_8859_8 */
-/* #undef _ICONV_TO_ENCODING_ISO_8859_9 */
-/* #undef _ICONV_TO_ENCODING_ISO_IR_111 */
-/* #undef _ICONV_TO_ENCODING_KOI8_R */
-/* #undef _ICONV_TO_ENCODING_KOI8_RU */
-/* #undef _ICONV_TO_ENCODING_KOI8_U */
-/* #undef _ICONV_TO_ENCODING_KOI8_UNI */
-/* #undef _ICONV_TO_ENCODING_UCS_2 */
-/* #undef _ICONV_TO_ENCODING_UCS_2_INTERNAL */
-/* #undef _ICONV_TO_ENCODING_UCS_2BE */
-/* #undef _ICONV_TO_ENCODING_UCS_2LE */
-/* #undef _ICONV_TO_ENCODING_UCS_4 */
-/* #undef _ICONV_TO_ENCODING_UCS_4_INTERNAL */
-/* #undef _ICONV_TO_ENCODING_UCS_4BE */
-/* #undef _ICONV_TO_ENCODING_UCS_4LE */
-/* #undef _ICONV_TO_ENCODING_US_ASCII */
-/* #undef _ICONV_TO_ENCODING_UTF_16 */
-/* #undef _ICONV_TO_ENCODING_UTF_16BE */
-/* #undef _ICONV_TO_ENCODING_UTF_16LE */
-/* #undef _ICONV_TO_ENCODING_UTF_8 */
-/* #undef _ICONV_TO_ENCODING_WIN_1250 */
-/* #undef _ICONV_TO_ENCODING_WIN_1251 */
-/* #undef _ICONV_TO_ENCODING_WIN_1252 */
-/* #undef _ICONV_TO_ENCODING_WIN_1253 */
-/* #undef _ICONV_TO_ENCODING_WIN_1254 */
-/* #undef _ICONV_TO_ENCODING_WIN_1255 */
-/* #undef _ICONV_TO_ENCODING_WIN_1256 */
-/* #undef _ICONV_TO_ENCODING_WIN_1257 */
-/* #undef _ICONV_TO_ENCODING_WIN_1258 */
-
-/*
- * Iconv encodings enabled ("from" direction)
- */
-/* #undef _ICONV_FROM_ENCODING_BIG5 */
-/* #undef _ICONV_FROM_ENCODING_CP775 */
-/* #undef _ICONV_FROM_ENCODING_CP850 */
-/* #undef _ICONV_FROM_ENCODING_CP852 */
-/* #undef _ICONV_FROM_ENCODING_CP855 */
-/* #undef _ICONV_FROM_ENCODING_CP866 */
-/* #undef _ICONV_FROM_ENCODING_EUC_JP */
-/* #undef _ICONV_FROM_ENCODING_EUC_TW */
-/* #undef _ICONV_FROM_ENCODING_EUC_KR */
-/* #undef _ICONV_FROM_ENCODING_ISO_8859_1 */
-/* #undef _ICONV_FROM_ENCODING_ISO_8859_10 */
-/* #undef _ICONV_FROM_ENCODING_ISO_8859_11 */
-/* #undef _ICONV_FROM_ENCODING_ISO_8859_13 */
-/* #undef _ICONV_FROM_ENCODING_ISO_8859_14 */
-/* #undef _ICONV_FROM_ENCODING_ISO_8859_15 */
-/* #undef _ICONV_FROM_ENCODING_ISO_8859_2 */
-/* #undef _ICONV_FROM_ENCODING_ISO_8859_3 */
-/* #undef _ICONV_FROM_ENCODING_ISO_8859_4 */
-/* #undef _ICONV_FROM_ENCODING_ISO_8859_5 */
-/* #undef _ICONV_FROM_ENCODING_ISO_8859_6 */
-/* #undef _ICONV_FROM_ENCODING_ISO_8859_7 */
-/* #undef _ICONV_FROM_ENCODING_ISO_8859_8 */
-/* #undef _ICONV_FROM_ENCODING_ISO_8859_9 */
-/* #undef _ICONV_FROM_ENCODING_ISO_IR_111 */
-/* #undef _ICONV_FROM_ENCODING_KOI8_R */
-/* #undef _ICONV_FROM_ENCODING_KOI8_RU */
-/* #undef _ICONV_FROM_ENCODING_KOI8_U */
-/* #undef _ICONV_FROM_ENCODING_KOI8_UNI */
-/* #undef _ICONV_FROM_ENCODING_UCS_2 */
-/* #undef _ICONV_FROM_ENCODING_UCS_2_INTERNAL */
-/* #undef _ICONV_FROM_ENCODING_UCS_2BE */
-/* #undef _ICONV_FROM_ENCODING_UCS_2LE */
-/* #undef _ICONV_FROM_ENCODING_UCS_4 */
-/* #undef _ICONV_FROM_ENCODING_UCS_4_INTERNAL */
-/* #undef _ICONV_FROM_ENCODING_UCS_4BE */
-/* #undef _ICONV_FROM_ENCODING_UCS_4LE */
-/* #undef _ICONV_FROM_ENCODING_US_ASCII */
-/* #undef _ICONV_FROM_ENCODING_UTF_16 */
-/* #undef _ICONV_FROM_ENCODING_UTF_16BE */
-/* #undef _ICONV_FROM_ENCODING_UTF_16LE */
-/* #undef _ICONV_FROM_ENCODING_UTF_8 */
-/* #undef _ICONV_FROM_ENCODING_WIN_1250 */
-/* #undef _ICONV_FROM_ENCODING_WIN_1251 */
-/* #undef _ICONV_FROM_ENCODING_WIN_1252 */
-/* #undef _ICONV_FROM_ENCODING_WIN_1253 */
-/* #undef _ICONV_FROM_ENCODING_WIN_1254 */
-/* #undef _ICONV_FROM_ENCODING_WIN_1255 */
-/* #undef _ICONV_FROM_ENCODING_WIN_1256 */
-/* #undef _ICONV_FROM_ENCODING_WIN_1257 */
-/* #undef _ICONV_FROM_ENCODING_WIN_1258 */
-
-#endif /* !__NEWLIB_H__ */
-

src/include/printf.h

@@ -1,117 +0,0 @@
-///////////////////////////////////////////////////////////////////////////////
-// \author (c) Marco Paland (info@paland.com)
-//             2014-2019, PALANDesign Hannover, Germany
-//
-// \license The MIT License (MIT)
-//
-// Permission is hereby granted, free of charge, to any person obtaining a copy
-// of this software and associated documentation files (the "Software"), to deal
-// in the Software without restriction, including without limitation the rights
-// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-// copies of the Software, and to permit persons to whom the Software is
-// furnished to do so, subject to the following conditions:
-// 
-// The above copyright notice and this permission notice shall be included in
-// all copies or substantial portions of the Software.
-// 
-// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
-// THE SOFTWARE.
-//
-// \brief Tiny printf, sprintf and snprintf implementation, optimized for speed on
-//        embedded systems with a very limited resources.
-//        Use this instead of bloated standard/newlib printf.
-//        These routines are thread safe and reentrant.
-//
-///////////////////////////////////////////////////////////////////////////////
-
-#ifndef _PRINTF_H_
-#define _PRINTF_H_
-
-#include <stdarg.h>
-#include <stddef.h>
-
-
-#ifdef __cplusplus
-extern "C" {
-#endif
-
-
-/**
- * Output a character to a custom device like UART, used by the printf() function
- * This function is declared here only. You have to write your custom implementation somewhere
- * \param character Character to output
- */
-void _putchar(char character);
-
-
-/**
- * Tiny printf implementation
- * You have to implement _putchar if you use printf()
- * To avoid conflicts with the regular printf() API it is overridden by macro defines
- * and internal underscore-appended functions like printf_() are used
- * \param format A string that specifies the format of the output
- * \return The number of characters that are written into the array, not counting the terminating null character
- */
-#define printf printf_
-#define __printf__ printf_
-int printf_(const char* format, ...);
-
-
-/**
- * Tiny sprintf implementation
- * Due to security reasons (buffer overflow) YOU SHOULD CONSIDER USING (V)SNPRINTF INSTEAD!
- * \param buffer A pointer to the buffer where to store the formatted string. MUST be big enough to store the output!
- * \param format A string that specifies the format of the output
- * \return The number of characters that are WRITTEN into the buffer, not counting the terminating null character
- */
-#define sprintf sprintf_
-int sprintf_(char* buffer, const char* format, ...);
-
-
-/**
- * Tiny snprintf/vsnprintf implementation
- * \param buffer A pointer to the buffer where to store the formatted string
- * \param count The maximum number of characters to store in the buffer, including a terminating null character
- * \param format A string that specifies the format of the output
- * \param va A value identifying a variable arguments list
- * \return The number of characters that COULD have been written into the buffer, not counting the terminating
- *         null character. A value equal or larger than count indicates truncation. Only when the returned value
- *         is non-negative and less than count, the string has been completely written.
- */
-#define snprintf  snprintf_
-#define vsnprintf vsnprintf_
-int  snprintf_(char* buffer, size_t count, const char* format, ...);
-int vsnprintf_(char* buffer, size_t count, const char* format, va_list va);
-
-
-/**
- * Tiny vprintf implementation
- * \param format A string that specifies the format of the output
- * \param va A value identifying a variable arguments list
- * \return The number of characters that are WRITTEN into the buffer, not counting the terminating null character
- */
-#define vprintf vprintf_
-int vprintf_(const char* format, va_list va);
-
-
-/**
- * printf with output function
- * You may use this as dynamic alternative to printf() with its fixed _putchar() output
- * \param out An output function which takes one character and an argument pointer
- * \param arg An argument pointer for user data passed to output function
- * \param format A string that specifies the format of the output
- * \return The number of characters that are sent to the output function, not counting the terminating null character
- */
-int fctprintf(void (*out)(char character, void* arg), void* arg, const char* format, ...);
-
-#ifdef __cplusplus
-}
-#endif
-
-
-#endif  // _PRINTF_H_

src/include/stdint.h

@@ -1,466 +0,0 @@
-/*
- * Copyright (c) 2004, 2005 by
- * Ralf Corsepius, Ulm/Germany. All rights reserved.
- *
- * Permission to use, copy, modify, and distribute this software
- * is freely granted, provided that this notice is preserved.
- */
-
-#ifndef _STDINT_H
-#define _STDINT_H
-
-#include <machine/_default_types.h>
-#include <sys/_intsup.h>
-#include <sys/_stdint.h>
-
-#ifdef __cplusplus
-extern "C" {
-#endif
-
-#ifdef ___int_least8_t_defined
-typedef __int_least8_t int_least8_t;
-typedef __uint_least8_t uint_least8_t;
-#define __int_least8_t_defined 1
-#endif
-
-#ifdef ___int_least16_t_defined
-typedef __int_least16_t int_least16_t;
-typedef __uint_least16_t uint_least16_t;
-#define __int_least16_t_defined 1
-#endif
-
-#ifdef ___int_least32_t_defined
-typedef __int_least32_t int_least32_t;
-typedef __uint_least32_t uint_least32_t;
-#define __int_least32_t_defined 1
-#endif
-
-#ifdef ___int_least64_t_defined
-typedef __int_least64_t int_least64_t;
-typedef __uint_least64_t uint_least64_t;
-#define __int_least64_t_defined 1
-#endif
-
-/*
- * Fastest minimum-width integer types
- *
- * Assume int to be the fastest type for all types with a width 
- * less than __INT_MAX__ rsp. INT_MAX
- */
-#ifdef __INT_FAST8_TYPE__
-  typedef __INT_FAST8_TYPE__ int_fast8_t;
-  typedef __UINT_FAST8_TYPE__ uint_fast8_t;
-#define __int_fast8_t_defined 1
-#elif __STDINT_EXP(INT_MAX) >= 0x7f
-  typedef signed int int_fast8_t;
-  typedef unsigned int uint_fast8_t;
-#define __int_fast8_t_defined 1
-#endif
-
-#ifdef __INT_FAST16_TYPE__
-  typedef __INT_FAST16_TYPE__ int_fast16_t;
-  typedef __UINT_FAST16_TYPE__ uint_fast16_t;
-#define __int_fast16_t_defined 1
-#elif __STDINT_EXP(INT_MAX) >= 0x7fff
-  typedef signed int int_fast16_t;
-  typedef unsigned int uint_fast16_t;
-#define __int_fast16_t_defined 1
-#endif
-
-#ifdef __INT_FAST32_TYPE__
-  typedef __INT_FAST32_TYPE__ int_fast32_t;
-  typedef __UINT_FAST32_TYPE__ uint_fast32_t;
-#define __int_fast32_t_defined 1
-#elif __STDINT_EXP(INT_MAX) >= 0x7fffffff
-  typedef signed int int_fast32_t;
-  typedef unsigned int uint_fast32_t;
-#define __int_fast32_t_defined 1
-#endif
-
-#ifdef __INT_FAST64_TYPE__
-  typedef __INT_FAST64_TYPE__ int_fast64_t;
-  typedef __UINT_FAST64_TYPE__ uint_fast64_t;
-#define __int_fast64_t_defined 1
-#elif __STDINT_EXP(INT_MAX) > 0x7fffffff
-  typedef signed int int_fast64_t;
-  typedef unsigned int uint_fast64_t;
-#define __int_fast64_t_defined 1
-#endif
-
-/*
- * Fall back to [u]int_least<N>_t for [u]int_fast<N>_t types
- * not having been defined, yet.
- * Leave undefined, if [u]int_least<N>_t should not be available.
- */
-#if !__int_fast8_t_defined
-#if __int_least8_t_defined
-  typedef int_least8_t int_fast8_t;
-  typedef uint_least8_t uint_fast8_t;
-#define __int_fast8_t_defined 1
-#endif
-#endif
-
-#if !__int_fast16_t_defined
-#if __int_least16_t_defined
-  typedef int_least16_t int_fast16_t;
-  typedef uint_least16_t uint_fast16_t;
-#define __int_fast16_t_defined 1
-#endif
-#endif
-
-#if !__int_fast32_t_defined
-#if __int_least32_t_defined
-  typedef int_least32_t int_fast32_t;
-  typedef uint_least32_t uint_fast32_t;
-#define __int_fast32_t_defined 1
-#endif
-#endif
-
-#if !__int_fast64_t_defined
-#if __int_least64_t_defined
-  typedef int_least64_t int_fast64_t;
-  typedef uint_least64_t uint_fast64_t;
-#define __int_fast64_t_defined 1
-#endif
-#endif
-
-#ifdef __INTPTR_TYPE__
-#define INTPTR_MIN (-__INTPTR_MAX__ - 1)
-#define INTPTR_MAX (__INTPTR_MAX__)
-#define UINTPTR_MAX (__UINTPTR_MAX__)
-#elif defined(__PTRDIFF_TYPE__)
-#define INTPTR_MAX PTRDIFF_MAX
-#define INTPTR_MIN PTRDIFF_MIN
-#ifdef __UINTPTR_MAX__
-#define UINTPTR_MAX (__UINTPTR_MAX__)
-#else
-#define UINTPTR_MAX (2UL * PTRDIFF_MAX + 1)
-#endif
-#else
-/*
- * Fallback to hardcoded values, 
- * should be valid on cpu's with 32bit int/32bit void*
- */
-#define INTPTR_MAX (__STDINT_EXP(LONG_MAX))
-#define INTPTR_MIN (-__STDINT_EXP(LONG_MAX) - 1)
-#define UINTPTR_MAX (__STDINT_EXP(LONG_MAX) * 2UL + 1)
-#endif
-
-/* Limits of Specified-Width Integer Types */
-
-#ifdef __INT8_MAX__
-#define INT8_MIN (-__INT8_MAX__ - 1)
-#define INT8_MAX (__INT8_MAX__)
-#define UINT8_MAX (__UINT8_MAX__)
-#elif defined(__int8_t_defined)
-#define INT8_MIN 	(-128)
-#define INT8_MAX 	 (127)
-#define UINT8_MAX 	 (255)
-#endif
-
-#ifdef __INT_LEAST8_MAX__
-#define INT_LEAST8_MIN (-__INT_LEAST8_MAX__ - 1)
-#define INT_LEAST8_MAX (__INT_LEAST8_MAX__)
-#define UINT_LEAST8_MAX (__UINT_LEAST8_MAX__)
-#elif defined(__int_least8_t_defined)
-#define INT_LEAST8_MIN 	(-128)
-#define INT_LEAST8_MAX 	 (127)
-#define UINT_LEAST8_MAX	 (255)
-#else
-#error required type int_least8_t missing
-#endif
-
-#ifdef __INT16_MAX__
-#define INT16_MIN (-__INT16_MAX__ - 1)
-#define INT16_MAX (__INT16_MAX__)
-#define UINT16_MAX (__UINT16_MAX__)
-#elif defined(__int16_t_defined)
-#define INT16_MIN 	(-32768)
-#define INT16_MAX 	 (32767)
-#define UINT16_MAX 	 (65535)
-#endif
-
-#ifdef __INT_LEAST16_MAX__
-#define INT_LEAST16_MIN (-__INT_LEAST16_MAX__ - 1)
-#define INT_LEAST16_MAX (__INT_LEAST16_MAX__)
-#define UINT_LEAST16_MAX (__UINT_LEAST16_MAX__)
-#elif defined(__int_least16_t_defined)
-#define INT_LEAST16_MIN	(-32768)
-#define INT_LEAST16_MAX	 (32767)
-#define UINT_LEAST16_MAX (65535)
-#else
-#error required type int_least16_t missing
-#endif
-
-#ifdef __INT32_MAX__
-#define INT32_MIN (-__INT32_MAX__ - 1)
-#define INT32_MAX (__INT32_MAX__)
-#define UINT32_MAX (__UINT32_MAX__)
-#elif defined(__int32_t_defined)
-#if defined (_INT32_EQ_LONG)
-#define INT32_MIN 	 (-2147483647L-1)
-#define INT32_MAX 	 (2147483647L)
-#define UINT32_MAX       (4294967295UL)
-#else
-#define INT32_MIN 	 (-2147483647-1)
-#define INT32_MAX 	 (2147483647)
-#define UINT32_MAX       (4294967295U)
-#endif
-#endif
-
-#ifdef __INT_LEAST32_MAX__
-#define INT_LEAST32_MIN (-__INT_LEAST32_MAX__ - 1)
-#define INT_LEAST32_MAX (__INT_LEAST32_MAX__)
-#define UINT_LEAST32_MAX (__UINT_LEAST32_MAX__)
-#elif defined(__int_least32_t_defined)
-#if defined (_INT32_EQ_LONG)
-#define INT_LEAST32_MIN  (-2147483647L-1)
-#define INT_LEAST32_MAX  (2147483647L)
-#define UINT_LEAST32_MAX (4294967295UL)
-#else
-#define INT_LEAST32_MIN  (-2147483647-1)
-#define INT_LEAST32_MAX  (2147483647)
-#define UINT_LEAST32_MAX (4294967295U)
-#endif
-#else
-#error required type int_least32_t missing
-#endif
-
-#ifdef __INT64_MAX__
-#define INT64_MIN (-__INT64_MAX__ - 1)
-#define INT64_MAX (__INT64_MAX__)
-#define UINT64_MAX (__UINT64_MAX__)
-#elif defined(__int64_t_defined)
-#if __have_long64
-#define INT64_MIN 	(-9223372036854775807L-1L)
-#define INT64_MAX 	 (9223372036854775807L)
-#define UINT64_MAX 	(18446744073709551615U)
-#elif __have_longlong64
-#define INT64_MIN 	(-9223372036854775807LL-1LL)
-#define INT64_MAX 	 (9223372036854775807LL)
-#define UINT64_MAX 	(18446744073709551615ULL)
-#endif
-#endif
-
-#ifdef __INT_LEAST64_MAX__
-#define INT_LEAST64_MIN (-__INT_LEAST64_MAX__ - 1)
-#define INT_LEAST64_MAX (__INT_LEAST64_MAX__)
-#define UINT_LEAST64_MAX (__UINT_LEAST64_MAX__)
-#elif defined(__int_least64_t_defined)
-#if __have_long64
-#define INT_LEAST64_MIN  (-9223372036854775807L-1L)
-#define INT_LEAST64_MAX  (9223372036854775807L)
-#define UINT_LEAST64_MAX (18446744073709551615U)
-#elif __have_longlong64
-#define INT_LEAST64_MIN  (-9223372036854775807LL-1LL)
-#define INT_LEAST64_MAX  (9223372036854775807LL)
-#define UINT_LEAST64_MAX (18446744073709551615ULL)
-#endif
-#endif
-
-#ifdef __INT_FAST8_MAX__
-#define INT_FAST8_MIN (-__INT_FAST8_MAX__ - 1)
-#define INT_FAST8_MAX (__INT_FAST8_MAX__)
-#define UINT_FAST8_MAX (__UINT_FAST8_MAX__)
-#elif defined(__int_fast8_t_defined)
-#if __STDINT_EXP(INT_MAX) >= 0x7f
-#define INT_FAST8_MIN	(-__STDINT_EXP(INT_MAX)-1)
-#define INT_FAST8_MAX	(__STDINT_EXP(INT_MAX))
-#define UINT_FAST8_MAX	(__STDINT_EXP(INT_MAX)*2U+1U)
-#else
-#define INT_FAST8_MIN	INT_LEAST8_MIN
-#define INT_FAST8_MAX	INT_LEAST8_MAX
-#define UINT_FAST8_MAX	UINT_LEAST8_MAX
-#endif
-#endif
-
-#ifdef __INT_FAST16_MAX__
-#define INT_FAST16_MIN (-__INT_FAST16_MAX__ - 1)
-#define INT_FAST16_MAX (__INT_FAST16_MAX__)
-#define UINT_FAST16_MAX (__UINT_FAST16_MAX__)
-#elif defined(__int_fast16_t_defined)
-#if __STDINT_EXP(INT_MAX) >= 0x7fff
-#define INT_FAST16_MIN	(-__STDINT_EXP(INT_MAX)-1)
-#define INT_FAST16_MAX	(__STDINT_EXP(INT_MAX))
-#define UINT_FAST16_MAX	(__STDINT_EXP(INT_MAX)*2U+1U)
-#else
-#define INT_FAST16_MIN	INT_LEAST16_MIN
-#define INT_FAST16_MAX	INT_LEAST16_MAX
-#define UINT_FAST16_MAX	UINT_LEAST16_MAX
-#endif
-#endif
-
-#ifdef __INT_FAST32_MAX__
-#define INT_FAST32_MIN (-__INT_FAST32_MAX__ - 1)
-#define INT_FAST32_MAX (__INT_FAST32_MAX__)
-#define UINT_FAST32_MAX (__UINT_FAST32_MAX__)
-#elif defined(__int_fast32_t_defined)
-#if __STDINT_EXP(INT_MAX) >= 0x7fffffff
-#define INT_FAST32_MIN	(-__STDINT_EXP(INT_MAX)-1)
-#define INT_FAST32_MAX	(__STDINT_EXP(INT_MAX))
-#define UINT_FAST32_MAX	(__STDINT_EXP(INT_MAX)*2U+1U)
-#else
-#define INT_FAST32_MIN	INT_LEAST32_MIN
-#define INT_FAST32_MAX	INT_LEAST32_MAX
-#define UINT_FAST32_MAX	UINT_LEAST32_MAX
-#endif
-#endif
-
-#ifdef __INT_FAST64_MAX__
-#define INT_FAST64_MIN (-__INT_FAST64_MAX__ - 1)
-#define INT_FAST64_MAX (__INT_FAST64_MAX__)
-#define UINT_FAST64_MAX (__UINT_FAST64_MAX__)
-#elif defined(__int_fast64_t_defined)
-#if __STDINT_EXP(INT_MAX) > 0x7fffffff
-#define INT_FAST64_MIN	(-__STDINT_EXP(INT_MAX)-1)
-#define INT_FAST64_MAX	(__STDINT_EXP(INT_MAX))
-#define UINT_FAST64_MAX	(__STDINT_EXP(INT_MAX)*2U+1U)
-#else
-#define INT_FAST64_MIN	INT_LEAST64_MIN
-#define INT_FAST64_MAX	INT_LEAST64_MAX
-#define UINT_FAST64_MAX	UINT_LEAST64_MAX
-#endif
-#endif
-
-#ifdef __INTMAX_MAX__
-#define INTMAX_MAX (__INTMAX_MAX__)
-#define INTMAX_MIN (-INTMAX_MAX - 1)
-#elif defined(__INTMAX_TYPE__)
-/* All relevant GCC versions prefer long to long long for intmax_t.  */
-#define INTMAX_MAX INT64_MAX
-#define INTMAX_MIN INT64_MIN
-#endif
-
-#ifdef __UINTMAX_MAX__
-#define UINTMAX_MAX (__UINTMAX_MAX__)
-#elif defined(__UINTMAX_TYPE__)
-/* All relevant GCC versions prefer long to long long for intmax_t.  */
-#define UINTMAX_MAX UINT64_MAX
-#endif
-
-/* This must match size_t in stddef.h, currently long unsigned int */
-#ifdef __SIZE_MAX__
-#define SIZE_MAX (__SIZE_MAX__)
-#else
-#define SIZE_MAX (__STDINT_EXP(LONG_MAX) * 2UL + 1)
-#endif
-
-/* This must match sig_atomic_t in <signal.h> (currently int) */
-#define SIG_ATOMIC_MIN (-__STDINT_EXP(INT_MAX) - 1)
-#define SIG_ATOMIC_MAX (__STDINT_EXP(INT_MAX))
-
-/* This must match ptrdiff_t  in <stddef.h> (currently long int) */
-#ifdef __PTRDIFF_MAX__
-#define PTRDIFF_MAX (__PTRDIFF_MAX__)
-#else
-#define PTRDIFF_MAX (__STDINT_EXP(LONG_MAX))
-#endif
-#define PTRDIFF_MIN (-PTRDIFF_MAX - 1)
-
-/* This must match definition in <wchar.h> */
-#ifndef WCHAR_MIN
-#ifdef __WCHAR_MIN__
-#define WCHAR_MIN (__WCHAR_MIN__)
-#elif defined(__WCHAR_UNSIGNED__) || (L'\0' - 1 > 0)
-#define WCHAR_MIN (0 + L'\0')
-#else
-#define WCHAR_MIN (-0x7fffffff - 1 + L'\0')
-#endif
-#endif
-
-/* This must match definition in <wchar.h> */
-#ifndef WCHAR_MAX
-#ifdef __WCHAR_MAX__
-#define WCHAR_MAX (__WCHAR_MAX__)
-#elif defined(__WCHAR_UNSIGNED__) || (L'\0' - 1 > 0)
-#define WCHAR_MAX (0xffffffffu + L'\0')
-#else
-#define WCHAR_MAX (0x7fffffff + L'\0')
-#endif
-#endif
-
-/* wint_t is unsigned int on almost all GCC targets.  */
-#ifdef __WINT_MAX__
-#define WINT_MAX (__WINT_MAX__)
-#else
-#define WINT_MAX (__STDINT_EXP(INT_MAX) * 2U + 1U)
-#endif
-#ifdef __WINT_MIN__
-#define WINT_MIN (__WINT_MIN__)
-#else
-#define WINT_MIN (0U)
-#endif
-
-/** Macros for minimum-width integer constant expressions */
-#ifdef __INT8_C
-#define INT8_C(x) __INT8_C(x)
-#define UINT8_C(x) __UINT8_C(x)
-#else
-#define INT8_C(x)	x
-#if __STDINT_EXP(INT_MAX) > 0x7f
-#define UINT8_C(x)	x
-#else
-#define UINT8_C(x)	x##U
-#endif
-#endif
-
-#ifdef __INT16_C
-#define INT16_C(x) __INT16_C(x)
-#define UINT16_C(x) __UINT16_C(x)
-#else
-#define INT16_C(x)	x
-#if __STDINT_EXP(INT_MAX) > 0x7fff
-#define UINT16_C(x)	x
-#else
-#define UINT16_C(x)	x##U
-#endif
-#endif
-
-#ifdef __INT32_C
-#define INT32_C(x) __INT32_C(x)
-#define UINT32_C(x) __UINT32_C(x)
-#else
-#if defined (_INT32_EQ_LONG)
-#define INT32_C(x)	x##L
-#define UINT32_C(x)	x##UL
-#else
-#define INT32_C(x)	x
-#define UINT32_C(x)	x##U
-#endif
-#endif
-
-#ifdef __INT64_C
-#define INT64_C(x) __INT64_C(x)
-#define UINT64_C(x) __UINT64_C(x)
-#else
-#if __int64_t_defined
-#if __have_long64
-#define INT64_C(x)	x##L
-#define UINT64_C(x)	x##UL
-#else
-#define INT64_C(x)	x##LL
-#define UINT64_C(x)	x##ULL
-#endif
-#endif
-#endif
-
-/** Macros for greatest-width integer constant expression */
-#ifdef __INTMAX_C
-#define INTMAX_C(x) __INTMAX_C(x)
-#define UINTMAX_C(x) __UINTMAX_C(x)
-#else
-#if __have_long64
-#define INTMAX_C(x)	x##L
-#define UINTMAX_C(x)	x##UL
-#else
-#define INTMAX_C(x)	x##LL
-#define UINTMAX_C(x)	x##ULL
-#endif
-#endif
-
-
-#ifdef __cplusplus
-}
-#endif
-
-#endif /* _STDINT_H */

src/include/stdio.h

@@ -1,804 +0,0 @@
-/*
- * Copyright (c) 1990 The Regents of the University of California.
- * All rights reserved.
- *
- * Redistribution and use in source and binary forms are permitted
- * provided that the above copyright notice and this paragraph are
- * duplicated in all such forms and that any documentation,
- * advertising materials, and other materials related to such
- * distribution and use acknowledge that the software was developed
- * by the University of California, Berkeley.  The name of the
- * University may not be used to endorse or promote products derived
- * from this software without specific prior written permission.
- * THIS SOFTWARE IS PROVIDED ``AS IS'' AND WITHOUT ANY EXPRESS OR
- * IMPLIED WARRANTIES, INCLUDING, WITHOUT LIMITATION, THE IMPLIED
- * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE.
- *
- *	@(#)stdio.h	5.3 (Berkeley) 3/15/86
- */
-
-/*
- * NB: to fit things in six character monocase externals, the
- * stdio code uses the prefix `__s' for stdio objects, typically
- * followed by a three-character attempt at a mnemonic.
- */
-
-#ifndef _STDIO_H_
-#define	_STDIO_H_
-
-#include "_ansi.h"
-
-#define	_FSTDIO			/* ``function stdio'' */
-
-#define __need_size_t
-#define __need_NULL
-#include <sys/cdefs.h>
-#include <stddef.h>
-#include <printf.h>
-
-/* typedef only __gnuc_va_list, used throughout the header */
-#define __need___va_list
-#include <stdarg.h>
-
-/* typedef va_list only when required */
-#if __POSIX_VISIBLE >= 200809 || __XSI_VISIBLE
-#ifdef __GNUC__
-#ifndef _VA_LIST_DEFINED
-typedef __gnuc_va_list va_list;
-#define _VA_LIST_DEFINED
-#endif
-#else /* !__GNUC__ */
-#include <stdarg.h>
-#endif
-#endif /* __POSIX_VISIBLE >= 200809 || __XSI_VISIBLE */
-
-/*
- * <sys/reent.h> defines __FILE, _fpos_t.
- * They must be defined there because struct _reent needs them (and we don't
- * want reent.h to include this file.
- */
-
-#include <sys/reent.h>
-#include <sys/types.h>
-
-_BEGIN_STD_C
-
-#if !defined(__FILE_defined)
-typedef __FILE FILE;
-# define __FILE_defined
-#endif
-
-#ifdef __CYGWIN__
-typedef _fpos64_t fpos_t;
-#else
-typedef _fpos_t fpos_t;
-#ifdef __LARGE64_FILES
-typedef _fpos64_t fpos64_t;
-#endif
-#endif /* !__CYGWIN__ */
-
-#include <sys/stdio.h>
-
-#define	__SLBF	0x0001		/* line buffered */
-#define	__SNBF	0x0002		/* unbuffered */
-#define	__SRD	0x0004		/* OK to read */
-#define	__SWR	0x0008		/* OK to write */
-	/* RD and WR are never simultaneously asserted */
-#define	__SRW	0x0010		/* open for reading & writing */
-#define	__SEOF	0x0020		/* found EOF */
-#define	__SERR	0x0040		/* found error */
-#define	__SMBF	0x0080		/* _buf is from malloc */
-#define	__SAPP	0x0100		/* fdopen()ed in append mode - so must  write to end */
-#define	__SSTR	0x0200		/* this is an sprintf/snprintf string */
-#define	__SOPT	0x0400		/* do fseek() optimisation */
-#define	__SNPT	0x0800		/* do not do fseek() optimisation */
-#define	__SOFF	0x1000		/* set iff _offset is in fact correct */
-#define	__SORD	0x2000		/* true => stream orientation (byte/wide) decided */
-#if defined(__CYGWIN__)
-#  define __SCLE  0x4000        /* convert line endings CR/LF <-> NL */
-#endif
-#define	__SL64	0x8000		/* is 64-bit offset large file */
-
-/* _flags2 flags */
-#define	__SNLK  0x0001		/* stdio functions do not lock streams themselves */
-#define	__SWID	0x2000		/* true => stream orientation wide, false => byte, only valid if __SORD in _flags is true */
-
-/*
- * The following three definitions are for ANSI C, which took them
- * from System V, which stupidly took internal interface macros and
- * made them official arguments to setvbuf(), without renaming them.
- * Hence, these ugly _IOxxx names are *supposed* to appear in user code.
- *
- * Although these happen to match their counterparts above, the
- * implementation does not rely on that (so these could be renumbered).
- */
-#define	_IOFBF	0		/* setvbuf should set fully buffered */
-#define	_IOLBF	1		/* setvbuf should set line buffered */
-#define	_IONBF	2		/* setvbuf should set unbuffered */
-
-#define	EOF	(-1)
-
-#ifdef __BUFSIZ__
-#define	BUFSIZ		__BUFSIZ__
-#else
-#define	BUFSIZ		1024
-#endif
-
-#ifdef __FOPEN_MAX__
-#define FOPEN_MAX	__FOPEN_MAX__
-#else
-#define	FOPEN_MAX	20
-#endif
-
-#ifdef __FILENAME_MAX__
-#define FILENAME_MAX    __FILENAME_MAX__
-#else
-#define	FILENAME_MAX	1024
-#endif
-
-#ifdef __L_tmpnam__
-#define L_tmpnam	__L_tmpnam__
-#else
-#define	L_tmpnam	FILENAME_MAX
-#endif
-
-#if __BSD_VISIBLE || __XSI_VISIBLE
-#define P_tmpdir        "/tmp"
-#endif
-
-#ifndef SEEK_SET
-#define	SEEK_SET	0	/* set file offset to offset */
-#endif
-#ifndef SEEK_CUR
-#define	SEEK_CUR	1	/* set file offset to current plus offset */
-#endif
-#ifndef SEEK_END
-#define	SEEK_END	2	/* set file offset to EOF plus offset */
-#endif
-
-#define	TMP_MAX		26
-
-#define	stdin	(_REENT->_stdin)
-#define	stdout	(_REENT->_stdout)
-#define	stderr	(_REENT->_stderr)
-
-#define _stdin_r(x)	((x)->_stdin)
-#define _stdout_r(x)	((x)->_stdout)
-#define _stderr_r(x)	((x)->_stderr)
-
-/*
- * Functions defined in ANSI C standard.
- */
-
-#ifndef __VALIST
-#ifdef __GNUC__
-#define __VALIST __gnuc_va_list
-#else
-#define __VALIST char*
-#endif
-#endif
-
-#if __POSIX_VISIBLE
-char *	ctermid (char *);
-#endif
-#if __GNU_VISIBLE || (__XSI_VISIBLE && __XSI_VISIBLE < 600)
-char *	cuserid (char *);
-#endif
-FILE *	tmpfile (void);
-char *	tmpnam (char *);
-#if __BSD_VISIBLE || __XSI_VISIBLE || __POSIX_VISIBLE >= 200112
-char *	tempnam (const char *, const char *) __malloc_like __result_use_check;
-#endif
-int	fclose (FILE *);
-int	fflush (FILE *);
-FILE *	freopen (const char *__restrict, const char *__restrict, FILE *__restrict);
-void	setbuf (FILE *__restrict, char *__restrict);
-int	setvbuf (FILE *__restrict, char *__restrict, int, size_t);
-int	fprintf (FILE *__restrict, const char *__restrict, ...)
-               _ATTRIBUTE ((__format__ (__printf__, 2, 3)));
-int	fscanf (FILE *__restrict, const char *__restrict, ...)
-               _ATTRIBUTE ((__format__ (__scanf__, 2, 3)));
-int	printf (const char *__restrict, ...)
-               _ATTRIBUTE ((__format__ (__printf__, 1, 2)));
-int	scanf (const char *__restrict, ...)
-               _ATTRIBUTE ((__format__ (__scanf__, 1, 2)));
-int	sscanf (const char *__restrict, const char *__restrict, ...)
-               _ATTRIBUTE ((__format__ (__scanf__, 2, 3)));
-int	vfprintf (FILE *__restrict, const char *__restrict, __VALIST)
-               _ATTRIBUTE ((__format__ (__printf__, 2, 0)));
-int	vprintf (const char *, __VALIST)
-               _ATTRIBUTE ((__format__ (__printf__, 1, 0)));
-int	vsprintf (char *__restrict, const char *__restrict, __VALIST)
-               _ATTRIBUTE ((__format__ (__printf__, 2, 0)));
-int	fgetc (FILE *);
-char *  fgets (char *__restrict, int, FILE *__restrict);
-int	fputc (int, FILE *);
-int	fputs (const char *__restrict, FILE *__restrict);
-int	getc (FILE *);
-int	getchar (void);
-char *  gets (char *);
-int	putc (int, FILE *);
-int	putchar (int);
-int	puts (const char *);
-int	ungetc (int, FILE *);
-size_t	fread (void *__restrict, size_t _size, size_t _n, FILE *__restrict);
-size_t	fwrite (const void *__restrict , size_t _size, size_t _n, FILE *);
-#ifdef _COMPILING_NEWLIB
-int	fgetpos (FILE *, _fpos_t *);
-#else
-int	fgetpos (FILE *__restrict, fpos_t *__restrict);
-#endif
-int	fseek (FILE *, long, int);
-#ifdef _COMPILING_NEWLIB
-int	fsetpos (FILE *, const _fpos_t *);
-#else
-int	fsetpos (FILE *, const fpos_t *);
-#endif
-long	ftell ( FILE *);
-void	rewind (FILE *);
-void	clearerr (FILE *);
-int	feof (FILE *);
-int	ferror (FILE *);
-void    perror (const char *);
-#ifndef _REENT_ONLY
-FILE *	fopen (const char *__restrict _name, const char *__restrict _type);
-int	sprintf (char *__restrict, const char *__restrict, ...)
-               _ATTRIBUTE ((__format__ (__printf__, 2, 3)));
-int	remove (const char *);
-int	rename (const char *, const char *);
-#ifdef _COMPILING_NEWLIB
-int	_rename (const char *, const char *);
-#endif
-#endif
-#if __LARGEFILE_VISIBLE || __POSIX_VISIBLE >= 200112
-#ifdef _COMPILING_NEWLIB
-int	fseeko (FILE *, _off_t, int);
-_off_t	ftello (FILE *);
-#else
-int	fseeko (FILE *, off_t, int);
-off_t	ftello (FILE *);
-#endif
-#endif
-#if __GNU_VISIBLE
-int	fcloseall (void);
-#endif
-#ifndef _REENT_ONLY
-#if __ISO_C_VISIBLE >= 1999
-int	snprintf (char *__restrict, size_t, const char *__restrict, ...)
-               _ATTRIBUTE ((__format__ (__printf__, 3, 4)));
-int	vsnprintf (char *__restrict, size_t, const char *__restrict, __VALIST)
-               _ATTRIBUTE ((__format__ (__printf__, 3, 0)));
-int	vfscanf (FILE *__restrict, const char *__restrict, __VALIST)
-               _ATTRIBUTE ((__format__ (__scanf__, 2, 0)));
-int	vscanf (const char *, __VALIST)
-               _ATTRIBUTE ((__format__ (__scanf__, 1, 0)));
-int	vsscanf (const char *__restrict, const char *__restrict, __VALIST)
-               _ATTRIBUTE ((__format__ (__scanf__, 2, 0)));
-#endif
-#if __GNU_VISIBLE
-int	asprintf (char **__restrict, const char *__restrict, ...)
-               _ATTRIBUTE ((__format__ (__printf__, 2, 3)));
-int	vasprintf (char **, const char *, __VALIST)
-               _ATTRIBUTE ((__format__ (__printf__, 2, 0)));
-#endif
-#if __MISC_VISIBLE /* Newlib-specific */
-int	asiprintf (char **, const char *, ...)
-               _ATTRIBUTE ((__format__ (__printf__, 2, 3)));
-char *	asniprintf (char *, size_t *, const char *, ...)
-               _ATTRIBUTE ((__format__ (__printf__, 3, 4)));
-char *	asnprintf (char *__restrict, size_t *__restrict, const char *__restrict, ...)
-               _ATTRIBUTE ((__format__ (__printf__, 3, 4)));
-#ifndef diprintf
-int	diprintf (int, const char *, ...)
-               _ATTRIBUTE ((__format__ (__printf__, 2, 3)));
-#endif
-int	fiprintf (FILE *, const char *, ...)
-               _ATTRIBUTE ((__format__ (__printf__, 2, 3)));
-int	fiscanf (FILE *, const char *, ...)
-               _ATTRIBUTE ((__format__ (__scanf__, 2, 3)));
-int	iprintf (const char *, ...)
-               _ATTRIBUTE ((__format__ (__printf__, 1, 2)));
-int	iscanf (const char *, ...)
-               _ATTRIBUTE ((__format__ (__scanf__, 1, 2)));
-int	siprintf (char *, const char *, ...)
-               _ATTRIBUTE ((__format__ (__printf__, 2, 3)));
-int	siscanf (const char *, const char *, ...)
-               _ATTRIBUTE ((__format__ (__scanf__, 2, 3)));
-int	sniprintf (char *, size_t, const char *, ...)
-               _ATTRIBUTE ((__format__ (__printf__, 3, 4)));
-int	vasiprintf (char **, const char *, __VALIST)
-               _ATTRIBUTE ((__format__ (__printf__, 2, 0)));
-char *	vasniprintf (char *, size_t *, const char *, __VALIST)
-               _ATTRIBUTE ((__format__ (__printf__, 3, 0)));
-char *	vasnprintf (char *, size_t *, const char *, __VALIST)
-               _ATTRIBUTE ((__format__ (__printf__, 3, 0)));
-int	vdiprintf (int, const char *, __VALIST)
-               _ATTRIBUTE ((__format__ (__printf__, 2, 0)));
-int	vfiprintf (FILE *, const char *, __VALIST)
-               _ATTRIBUTE ((__format__ (__printf__, 2, 0)));
-int	vfiscanf (FILE *, const char *, __VALIST)
-               _ATTRIBUTE ((__format__ (__scanf__, 2, 0)));
-int	viprintf (const char *, __VALIST)
-               _ATTRIBUTE ((__format__ (__printf__, 1, 0)));
-int	viscanf (const char *, __VALIST)
-               _ATTRIBUTE ((__format__ (__scanf__, 1, 0)));
-int	vsiprintf (char *, const char *, __VALIST)
-               _ATTRIBUTE ((__format__ (__printf__, 2, 0)));
-int	vsiscanf (const char *, const char *, __VALIST)
-               _ATTRIBUTE ((__format__ (__scanf__, 2, 0)));
-int	vsniprintf (char *, size_t, const char *, __VALIST)
-               _ATTRIBUTE ((__format__ (__printf__, 3, 0)));
-#endif /* __MISC_VISIBLE */
-#endif /* !_REENT_ONLY */
-
-/*
- * Routines in POSIX 1003.1:2001.
- */
-
-#if __POSIX_VISIBLE
-#ifndef _REENT_ONLY
-FILE *	fdopen (int, const char *);
-#endif
-int	fileno (FILE *);
-#endif
-#if __MISC_VISIBLE || __POSIX_VISIBLE >= 199209
-int	pclose (FILE *);
-FILE *  popen (const char *, const char *);
-#endif
-
-#if __BSD_VISIBLE
-void    setbuffer (FILE *, char *, int);
-int	setlinebuf (FILE *);
-#endif
-
-#if __MISC_VISIBLE || (__XSI_VISIBLE && __POSIX_VISIBLE < 200112)
-int	getw (FILE *);
-int	putw (int, FILE *);
-#endif
-#if __MISC_VISIBLE || __POSIX_VISIBLE
-int	getc_unlocked (FILE *);
-int	getchar_unlocked (void);
-void	flockfile (FILE *);
-int	ftrylockfile (FILE *);
-void	funlockfile (FILE *);
-int	putc_unlocked (int, FILE *);
-int	putchar_unlocked (int);
-#endif
-
-/*
- * Routines in POSIX 1003.1:200x.
- */
-
-#if __POSIX_VISIBLE >= 200809
-# ifndef _REENT_ONLY
-#  ifndef dprintf
-int	dprintf (int, const char *__restrict, ...)
-               _ATTRIBUTE ((__format__ (__printf__, 2, 3)));
-#  endif
-FILE *	fmemopen (void *__restrict, size_t, const char *__restrict);
-/* getdelim - see __getdelim for now */
-/* getline - see __getline for now */
-FILE *	open_memstream (char **, size_t *);
-int	vdprintf (int, const char *__restrict, __VALIST)
-               _ATTRIBUTE ((__format__ (__printf__, 2, 0)));
-# endif
-#endif
-#if __ATFILE_VISIBLE
-int	renameat (int, const char *, int, const char *);
-# ifdef __CYGWIN__
-int	renameat2 (int, const char *, int, const char *, unsigned int);
-# endif
-#endif
-
-/*
- * Recursive versions of the above.
- */
-
-int	_asiprintf_r (struct _reent *, char **, const char *, ...)
-               _ATTRIBUTE ((__format__ (__printf__, 3, 4)));
-char *	_asniprintf_r (struct _reent *, char *, size_t *, const char *, ...)
-               _ATTRIBUTE ((__format__ (__printf__, 4, 5)));
-char *	_asnprintf_r (struct _reent *, char *__restrict, size_t *__restrict, const char *__restrict, ...)
-               _ATTRIBUTE ((__format__ (__printf__, 4, 5)));
-int	_asprintf_r (struct _reent *, char **__restrict, const char *__restrict, ...)
-               _ATTRIBUTE ((__format__ (__printf__, 3, 4)));
-int	_diprintf_r (struct _reent *, int, const char *, ...)
-               _ATTRIBUTE ((__format__ (__printf__, 3, 4)));
-int	_dprintf_r (struct _reent *, int, const char *__restrict, ...)
-               _ATTRIBUTE ((__format__ (__printf__, 3, 4)));
-int	_fclose_r (struct _reent *, FILE *);
-int	_fcloseall_r (struct _reent *);
-FILE *	_fdopen_r (struct _reent *, int, const char *);
-int	_fflush_r (struct _reent *, FILE *);
-int	_fgetc_r (struct _reent *, FILE *);
-int	_fgetc_unlocked_r (struct _reent *, FILE *);
-char *  _fgets_r (struct _reent *, char *__restrict, int, FILE *__restrict);
-char *  _fgets_unlocked_r (struct _reent *, char *__restrict, int, FILE *__restrict);
-#ifdef _COMPILING_NEWLIB
-int	_fgetpos_r (struct _reent *, FILE *__restrict, _fpos_t *__restrict);
-int	_fsetpos_r (struct _reent *, FILE *, const _fpos_t *);
-#else
-int	_fgetpos_r (struct _reent *, FILE *, fpos_t *);
-int	_fsetpos_r (struct _reent *, FILE *, const fpos_t *);
-#endif
-int	_fiprintf_r (struct _reent *, FILE *, const char *, ...)
-               _ATTRIBUTE ((__format__ (__printf__, 3, 4)));
-int	_fiscanf_r (struct _reent *, FILE *, const char *, ...)
-               _ATTRIBUTE ((__format__ (__scanf__, 3, 4)));
-FILE *	_fmemopen_r (struct _reent *, void *__restrict, size_t, const char *__restrict);
-FILE *	_fopen_r (struct _reent *, const char *__restrict, const char *__restrict);
-FILE *	_freopen_r (struct _reent *, const char *__restrict, const char *__restrict, FILE *__restrict);
-int	_fprintf_r (struct _reent *, FILE *__restrict, const char *__restrict, ...)
-               _ATTRIBUTE ((__format__ (__printf__, 3, 4)));
-int	_fpurge_r (struct _reent *, FILE *);
-int	_fputc_r (struct _reent *, int, FILE *);
-int	_fputc_unlocked_r (struct _reent *, int, FILE *);
-int	_fputs_r (struct _reent *, const char *__restrict, FILE *__restrict);
-int	_fputs_unlocked_r (struct _reent *, const char *__restrict, FILE *__restrict);
-size_t	_fread_r (struct _reent *, void *__restrict, size_t _size, size_t _n, FILE *__restrict);
-size_t	_fread_unlocked_r (struct _reent *, void *__restrict, size_t _size, size_t _n, FILE *__restrict);
-int	_fscanf_r (struct _reent *, FILE *__restrict, const char *__restrict, ...)
-               _ATTRIBUTE ((__format__ (__scanf__, 3, 4)));
-int	_fseek_r (struct _reent *, FILE *, long, int);
-int	_fseeko_r (struct _reent *, FILE *, _off_t, int);
-long	_ftell_r (struct _reent *, FILE *);
-_off_t	_ftello_r (struct _reent *, FILE *);
-void	_rewind_r (struct _reent *, FILE *);
-size_t	_fwrite_r (struct _reent *, const void *__restrict, size_t _size, size_t _n, FILE *__restrict);
-size_t	_fwrite_unlocked_r (struct _reent *, const void *__restrict, size_t _size, size_t _n, FILE *__restrict);
-int	_getc_r (struct _reent *, FILE *);
-int	_getc_unlocked_r (struct _reent *, FILE *);
-int	_getchar_r (struct _reent *);
-int	_getchar_unlocked_r (struct _reent *);
-char *	_gets_r (struct _reent *, char *);
-int	_iprintf_r (struct _reent *, const char *, ...)
-               _ATTRIBUTE ((__format__ (__printf__, 2, 3)));
-int	_iscanf_r (struct _reent *, const char *, ...)
-               _ATTRIBUTE ((__format__ (__scanf__, 2, 3)));
-FILE *	_open_memstream_r (struct _reent *, char **, size_t *);
-void	_perror_r (struct _reent *, const char *);
-int	_printf_r (struct _reent *, const char *__restrict, ...)
-               _ATTRIBUTE ((__format__ (__printf__, 2, 3)));
-int	_putc_r (struct _reent *, int, FILE *);
-int	_putc_unlocked_r (struct _reent *, int, FILE *);
-int	_putchar_unlocked_r (struct _reent *, int);
-int	_putchar_r (struct _reent *, int);
-int	_puts_r (struct _reent *, const char *);
-int	_remove_r (struct _reent *, const char *);
-int	_rename_r (struct _reent *,
-			   const char *_old, const char *_new);
-int	_scanf_r (struct _reent *, const char *__restrict, ...)
-               _ATTRIBUTE ((__format__ (__scanf__, 2, 3)));
-int	_siprintf_r (struct _reent *, char *, const char *, ...)
-               _ATTRIBUTE ((__format__ (__printf__, 3, 4)));
-int	_siscanf_r (struct _reent *, const char *, const char *, ...)
-               _ATTRIBUTE ((__format__ (__scanf__, 3, 4)));
-int	_sniprintf_r (struct _reent *, char *, size_t, const char *, ...)
-               _ATTRIBUTE ((__format__ (__printf__, 4, 5)));
-int	_snprintf_r (struct _reent *, char *__restrict, size_t, const char *__restrict, ...)
-               _ATTRIBUTE ((__format__ (__printf__, 4, 5)));
-int	_sprintf_r (struct _reent *, char *__restrict, const char *__restrict, ...)
-               _ATTRIBUTE ((__format__ (__printf__, 3, 4)));
-int	_sscanf_r (struct _reent *, const char *__restrict, const char *__restrict, ...)
-               _ATTRIBUTE ((__format__ (__scanf__, 3, 4)));
-char *	_tempnam_r (struct _reent *, const char *, const char *);
-FILE *	_tmpfile_r (struct _reent *);
-char *	_tmpnam_r (struct _reent *, char *);
-int	_ungetc_r (struct _reent *, int, FILE *);
-int	_vasiprintf_r (struct _reent *, char **, const char *, __VALIST)
-               _ATTRIBUTE ((__format__ (__printf__, 3, 0)));
-char *	_vasniprintf_r (struct _reent*, char *, size_t *, const char *, __VALIST)
-               _ATTRIBUTE ((__format__ (__printf__, 4, 0)));
-char *	_vasnprintf_r (struct _reent*, char *, size_t *, const char *, __VALIST)
-               _ATTRIBUTE ((__format__ (__printf__, 4, 0)));
-int	_vasprintf_r (struct _reent *, char **, const char *, __VALIST)
-               _ATTRIBUTE ((__format__ (__printf__, 3, 0)));
-int	_vdiprintf_r (struct _reent *, int, const char *, __VALIST)
-               _ATTRIBUTE ((__format__ (__printf__, 3, 0)));
-int	_vdprintf_r (struct _reent *, int, const char *__restrict, __VALIST)
-               _ATTRIBUTE ((__format__ (__printf__, 3, 0)));
-int	_vfiprintf_r (struct _reent *, FILE *, const char *, __VALIST)
-               _ATTRIBUTE ((__format__ (__printf__, 3, 0)));
-int	_vfiscanf_r (struct _reent *, FILE *, const char *, __VALIST)
-               _ATTRIBUTE ((__format__ (__scanf__, 3, 0)));
-int	_vfprintf_r (struct _reent *, FILE *__restrict, const char *__restrict, __VALIST)
-               _ATTRIBUTE ((__format__ (__printf__, 3, 0)));
-int	_vfscanf_r (struct _reent *, FILE *__restrict, const char *__restrict, __VALIST)
-               _ATTRIBUTE ((__format__ (__scanf__, 3, 0)));
-int	_viprintf_r (struct _reent *, const char *, __VALIST)
-               _ATTRIBUTE ((__format__ (__printf__, 2, 0)));
-int	_viscanf_r (struct _reent *, const char *, __VALIST)
-               _ATTRIBUTE ((__format__ (__scanf__, 2, 0)));
-int	_vprintf_r (struct _reent *, const char *__restrict, __VALIST)
-               _ATTRIBUTE ((__format__ (__printf__, 2, 0)));
-int	_vscanf_r (struct _reent *, const char *__restrict, __VALIST)
-               _ATTRIBUTE ((__format__ (__scanf__, 2, 0)));
-int	_vsiprintf_r (struct _reent *, char *, const char *, __VALIST)
-               _ATTRIBUTE ((__format__ (__printf__, 3, 0)));
-int	_vsiscanf_r (struct _reent *, const char *, const char *, __VALIST)
-               _ATTRIBUTE ((__format__ (__scanf__, 3, 0)));
-int	_vsniprintf_r (struct _reent *, char *, size_t, const char *, __VALIST)
-               _ATTRIBUTE ((__format__ (__printf__, 4, 0)));
-int	_vsnprintf_r (struct _reent *, char *__restrict, size_t, const char *__restrict, __VALIST)
-               _ATTRIBUTE ((__format__ (__printf__, 4, 0)));
-int	_vsprintf_r (struct _reent *, char *__restrict, const char *__restrict, __VALIST)
-               _ATTRIBUTE ((__format__ (__printf__, 3, 0)));
-int	_vsscanf_r (struct _reent *, const char *__restrict, const char *__restrict, __VALIST)
-               _ATTRIBUTE ((__format__ (__scanf__, 3, 0)));
-
-/* Other extensions.  */
-
-int	fpurge (FILE *);
-ssize_t __getdelim (char **, size_t *, int, FILE *);
-ssize_t __getline (char **, size_t *, FILE *);
-
-#if __MISC_VISIBLE
-void	clearerr_unlocked (FILE *);
-int	feof_unlocked (FILE *);
-int	ferror_unlocked (FILE *);
-int	fileno_unlocked (FILE *);
-int	fflush_unlocked (FILE *);
-int	fgetc_unlocked (FILE *);
-int	fputc_unlocked (int, FILE *);
-size_t	fread_unlocked (void *__restrict, size_t _size, size_t _n, FILE *__restrict);
-size_t	fwrite_unlocked (const void *__restrict , size_t _size, size_t _n, FILE *);
-#endif
-
-#if __GNU_VISIBLE
-char *  fgets_unlocked (char *__restrict, int, FILE *__restrict);
-int	fputs_unlocked (const char *__restrict, FILE *__restrict);
-#endif
-
-#ifdef __LARGE64_FILES
-#if !defined(__CYGWIN__) || defined(_COMPILING_NEWLIB)
-FILE *	fdopen64 (int, const char *);
-FILE *  fopen64 (const char *, const char *);
-FILE *  freopen64 (const char *, const char *, FILE *);
-_off64_t ftello64 (FILE *);
-_off64_t fseeko64 (FILE *, _off64_t, int);
-int     fgetpos64 (FILE *, _fpos64_t *);
-int     fsetpos64 (FILE *, const _fpos64_t *);
-FILE *  tmpfile64 (void);
-
-FILE *	_fdopen64_r (struct _reent *, int, const char *);
-FILE *  _fopen64_r (struct _reent *,const char *, const char *);
-FILE *  _freopen64_r (struct _reent *, const char *, const char *, FILE *);
-_off64_t _ftello64_r (struct _reent *, FILE *);
-_off64_t _fseeko64_r (struct _reent *, FILE *, _off64_t, int);
-int     _fgetpos64_r (struct _reent *, FILE *, _fpos64_t *);
-int     _fsetpos64_r (struct _reent *, FILE *, const _fpos64_t *);
-FILE *  _tmpfile64_r (struct _reent *);
-#endif /* !__CYGWIN__ */
-#endif /* __LARGE64_FILES */
-
-/*
- * Routines internal to the implementation.
- */
-
-int	__srget_r (struct _reent *, FILE *);
-int	__swbuf_r (struct _reent *, int, FILE *);
-
-/*
- * Stdio function-access interface.
- */
-
-#if __BSD_VISIBLE
-# ifdef __LARGE64_FILES
-FILE	*funopen (const void *__cookie,
-		int (*__readfn)(void *__c, char *__buf,
-				_READ_WRITE_BUFSIZE_TYPE __n),
-		int (*__writefn)(void *__c, const char *__buf,
-				 _READ_WRITE_BUFSIZE_TYPE __n),
-		_fpos64_t (*__seekfn)(void *__c, _fpos64_t __off, int __whence),
-		int (*__closefn)(void *__c));
-FILE	*_funopen_r (struct _reent *, const void *__cookie,
-		int (*__readfn)(void *__c, char *__buf,
-				_READ_WRITE_BUFSIZE_TYPE __n),
-		int (*__writefn)(void *__c, const char *__buf,
-				 _READ_WRITE_BUFSIZE_TYPE __n),
-		_fpos64_t (*__seekfn)(void *__c, _fpos64_t __off, int __whence),
-		int (*__closefn)(void *__c));
-# else
-FILE	*funopen (const void *__cookie,
-		int (*__readfn)(void *__cookie, char *__buf,
-				_READ_WRITE_BUFSIZE_TYPE __n),
-		int (*__writefn)(void *__cookie, const char *__buf,
-				 _READ_WRITE_BUFSIZE_TYPE __n),
-		fpos_t (*__seekfn)(void *__cookie, fpos_t __off, int __whence),
-		int (*__closefn)(void *__cookie));
-FILE	*_funopen_r (struct _reent *, const void *__cookie,
-		int (*__readfn)(void *__cookie, char *__buf,
-				_READ_WRITE_BUFSIZE_TYPE __n),
-		int (*__writefn)(void *__cookie, const char *__buf,
-				 _READ_WRITE_BUFSIZE_TYPE __n),
-		fpos_t (*__seekfn)(void *__cookie, fpos_t __off, int __whence),
-		int (*__closefn)(void *__cookie));
-# endif /* !__LARGE64_FILES */
-
-# define	fropen(__cookie, __fn) funopen(__cookie, __fn, (int (*)())0, \
-					       (fpos_t (*)())0, (int (*)())0)
-# define	fwopen(__cookie, __fn) funopen(__cookie, (int (*)())0, __fn, \
-					       (fpos_t (*)())0, (int (*)())0)
-#endif /* __BSD_VISIBLE */
-
-#if __GNU_VISIBLE
-typedef ssize_t cookie_read_function_t(void *__cookie, char *__buf, size_t __n);
-typedef ssize_t cookie_write_function_t(void *__cookie, const char *__buf,
-					size_t __n);
-# ifdef __LARGE64_FILES
-typedef int cookie_seek_function_t(void *__cookie, _off64_t *__off,
-				   int __whence);
-# else
-typedef int cookie_seek_function_t(void *__cookie, off_t *__off, int __whence);
-# endif /* !__LARGE64_FILES */
-typedef int cookie_close_function_t(void *__cookie);
-typedef struct
-{
-  /* These four struct member names are dictated by Linux; hopefully,
-     they don't conflict with any macros.  */
-  cookie_read_function_t  *read;
-  cookie_write_function_t *write;
-  cookie_seek_function_t  *seek;
-  cookie_close_function_t *close;
-} cookie_io_functions_t;
-FILE *fopencookie (void *__cookie,
-		const char *__mode, cookie_io_functions_t __functions);
-FILE *_fopencookie_r (struct _reent *, void *__cookie,
-		const char *__mode, cookie_io_functions_t __functions);
-#endif /* __GNU_VISIBLE */
-
-#ifndef __CUSTOM_FILE_IO__
-/*
- * The __sfoo macros are here so that we can 
- * define function versions in the C library.
- */
-#define       __sgetc_raw_r(__ptr, __f) (--(__f)->_r < 0 ? __srget_r(__ptr, __f) : (int)(*(__f)->_p++))
-
-#ifdef __SCLE
-/*  For a platform with CR/LF, additional logic is required by
-  __sgetc_r which would otherwise simply be a macro; therefore we
-  use an inlined function.  The function is only meant to be inlined
-  in place as used and the function body should never be emitted.  
-
-  There are two possible means to this end when compiling with GCC,
-  one when compiling with a standard C99 compiler, and for other
-  compilers we're just stuck.  At the moment, this issue only
-  affects the Cygwin target, so we'll most likely be using GCC. */
-
-_ELIDABLE_INLINE int __sgetc_r(struct _reent *__ptr, FILE *__p);
-
-_ELIDABLE_INLINE int __sgetc_r(struct _reent *__ptr, FILE *__p)
-  {
-    int __c = __sgetc_raw_r(__ptr, __p);
-    if ((__p->_flags & __SCLE) && (__c == '\r'))
-      {
-      int __c2 = __sgetc_raw_r(__ptr, __p);
-      if (__c2 == '\n')
-        __c = __c2;
-      else
-        ungetc(__c2, __p);
-      }
-    return __c;
-  }
-#else
-#define __sgetc_r(__ptr, __p) __sgetc_raw_r(__ptr, __p)
-#endif
-
-#ifdef __GNUC__
-_ELIDABLE_INLINE int __sputc_r(struct _reent *_ptr, int _c, FILE *_p) {
-#ifdef __SCLE
-	if ((_p->_flags & __SCLE) && _c == '\n')
-	  __sputc_r (_ptr, '\r', _p);
-#endif
-	if (--_p->_w >= 0 || (_p->_w >= _p->_lbfsize && (char)_c != '\n'))
-		return (*_p->_p++ = _c);
-	else
-		return (__swbuf_r(_ptr, _c, _p));
-}
-#else
-/*
- * This has been tuned to generate reasonable code on the vax using pcc
- */
-#define       __sputc_raw_r(__ptr, __c, __p) \
-	(--(__p)->_w < 0 ? \
-		(__p)->_w >= (__p)->_lbfsize ? \
-			(*(__p)->_p = (__c)), *(__p)->_p != '\n' ? \
-				(int)*(__p)->_p++ : \
-				__swbuf_r(__ptr, '\n', __p) : \
-			__swbuf_r(__ptr, (int)(__c), __p) : \
-		(*(__p)->_p = (__c), (int)*(__p)->_p++))
-#ifdef __SCLE
-#define __sputc_r(__ptr, __c, __p) \
-        ((((__p)->_flags & __SCLE) && ((__c) == '\n')) \
-          ? __sputc_raw_r(__ptr, '\r', (__p)) : 0 , \
-        __sputc_raw_r((__ptr), (__c), (__p)))
-#else
-#define __sputc_r(__ptr, __c, __p) __sputc_raw_r(__ptr, __c, __p)
-#endif
-#endif
-
-#define	__sfeof(p)	((int)(((p)->_flags & __SEOF) != 0))
-#define	__sferror(p)	((int)(((p)->_flags & __SERR) != 0))
-#define	__sclearerr(p)	((void)((p)->_flags &= ~(__SERR|__SEOF)))
-#define	__sfileno(p)	((p)->_file)
-
-#ifndef __cplusplus
-#ifndef _REENT_SMALL
-#define	feof(p)		__sfeof(p)
-#define	ferror(p)	__sferror(p)
-#define	clearerr(p)	__sclearerr(p)
-
-#if __MISC_VISIBLE
-#define	feof_unlocked(p)	__sfeof(p)
-#define	ferror_unlocked(p)	__sferror(p)
-#define	clearerr_unlocked(p)	__sclearerr(p)
-#endif /* __MISC_VISIBLE */
-#endif /* _REENT_SMALL */
-
-#if 0 /* __POSIX_VISIBLE - FIXME: must initialize stdio first, use fn */
-#define	fileno(p)	__sfileno(p)
-#endif
-
-static __inline int
-_getchar_unlocked(void)
-{
-	struct _reent *_ptr;
-
-	_ptr = _REENT;
-	return (__sgetc_r(_ptr, _stdin_r(_ptr)));
-}
-
-static __inline int
-_putchar_unlocked(int _c)
-{
-	struct _reent *_ptr;
-
-	_ptr = _REENT;
-	return (__sputc_r(_ptr, _c, _stdout_r(_ptr)));
-}
-
-#ifdef __SINGLE_THREAD__
-#define	getc(_p)	__sgetc_r(_REENT, _p)
-#define	putc(_c, _p)	__sputc_r(_REENT, _c, _p)
-#define	getchar()	_getchar_unlocked()
-#define	putchar(_c)	_putchar_unlocked(_c)
-#endif /* __SINGLE_THREAD__ */
-
-#if __MISC_VISIBLE || __POSIX_VISIBLE
-#define	getchar_unlocked()	_getchar_unlocked()
-#define	putchar_unlocked(_c)	_putchar_unlocked(_c)
-#endif
-#endif /* __cplusplus */
-
-#if __MISC_VISIBLE
-/* fast always-buffered version, true iff error */
-#define	fast_putc(x,p) (--(p)->_w < 0 ? \
-	__swbuf_r(_REENT, (int)(x), p) == EOF : (*(p)->_p = (x), (p)->_p++, 0))
-#endif
-
-#if __GNU_VISIBLE || (__XSI_VISIBLE && __XSI_VISIBLE < 600)
-#define	L_cuserid	9		/* posix says it goes in stdio.h :( */
-#endif
-#if __POSIX_VISIBLE
-#define L_ctermid       16
-#endif
-
-#else /* __CUSTOM_FILE_IO__ */
-
-#define	getchar()	getc(stdin)
-#define	putchar(x)	putc(x, stdout)
-
-#if __MISC_VISIBLE || __POSIX_VISIBLE
-#define	getchar_unlocked()	getc_unlocked(stdin)
-#define	putchar_unlocked(x)	putc_unlocked(x, stdout)
-#endif
-
-#endif /* !__CUSTOM_FILE_IO__ */
-
-_END_STD_C
-
-#if __SSP_FORTIFY_LEVEL > 0
-#include <ssp/stdio.h>
-#endif
-
-#endif /* _STDIO_H_ */

src/include/stdlib.h

@@ -1,342 +0,0 @@
-/*
- * stdlib.h
- *
- * Definitions for common types, variables, and functions.
- */
-
-#ifndef _STDLIB_H_
-#define _STDLIB_H_
-
-#include <machine/ieeefp.h>
-#include "_ansi.h"
-
-#define __need_size_t
-#define __need_wchar_t
-#define __need_NULL
-#include <stddef.h>
-
-#include <sys/reent.h>
-#include <sys/cdefs.h>
-#include <machine/stdlib.h>
-#ifndef __STRICT_ANSI__
-#include <alloca.h>
-#endif
-
-#ifdef __CYGWIN__
-#include <cygwin/stdlib.h>
-#endif
-
-#if __GNU_VISIBLE
-#include <xlocale.h>
-#endif
-
-_BEGIN_STD_C
-
-typedef struct 
-{
-  int quot; /* quotient */
-  int rem; /* remainder */
-} div_t;
-
-typedef struct 
-{
-  long quot; /* quotient */
-  long rem; /* remainder */
-} ldiv_t;
-
-#if __ISO_C_VISIBLE >= 1999
-typedef struct
-{
-  long long int quot; /* quotient */
-  long long int rem; /* remainder */
-} lldiv_t;
-#endif
-
-#ifndef __compar_fn_t_defined
-#define __compar_fn_t_defined
-typedef int (*__compar_fn_t) (const void *, const void *);
-#endif
-
-#define EXIT_FAILURE 1
-#define EXIT_SUCCESS 0
-
-#define RAND_MAX __RAND_MAX
-
-int	__locale_mb_cur_max (void);
-
-#define MB_CUR_MAX __locale_mb_cur_max()
-
-void	abort (void) _ATTRIBUTE ((__noreturn__));
-int	abs (int);
-#if __BSD_VISIBLE
-__uint32_t arc4random (void);
-__uint32_t arc4random_uniform (__uint32_t);
-void    arc4random_buf (void *, size_t);
-#endif
-int	atexit (void (*__func)(void));
-double	atof (const char *__nptr);
-#if __MISC_VISIBLE
-float	atoff (const char *__nptr);
-#endif
-int	atoi (const char *__nptr);
-int	_atoi_r (struct _reent *, const char *__nptr);
-long	atol (const char *__nptr);
-long	_atol_r (struct _reent *, const char *__nptr);
-void *	bsearch (const void *__key,
-		       const void *__base,
-		       size_t __nmemb,
-		       size_t __size,
-		       __compar_fn_t _compar);
-void	*calloc(size_t, size_t) __malloc_like __result_use_check
-	     __alloc_size2(1, 2) _NOTHROW;
-div_t	div (int __numer, int __denom);
-void	exit (int __status) _ATTRIBUTE ((__noreturn__));
-void	free (void *) _NOTHROW;
-char *  getenv (const char *__string);
-char *	_getenv_r (struct _reent *, const char *__string);
-char *	_findenv (const char *, int *);
-char *	_findenv_r (struct _reent *, const char *, int *);
-#if __POSIX_VISIBLE >= 200809
-extern char *suboptarg;			/* getsubopt(3) external variable */
-int	getsubopt (char **, char * const *, char **);
-#endif
-long	labs (long);
-ldiv_t	ldiv (long __numer, long __denom);
-void	*malloc(size_t) __malloc_like __result_use_check __alloc_size(1) _NOTHROW;
-int	mblen (const char *, size_t);
-int	_mblen_r (struct _reent *, const char *, size_t, _mbstate_t *);
-int	mbtowc (wchar_t *__restrict, const char *__restrict, size_t);
-int	_mbtowc_r (struct _reent *, wchar_t *__restrict, const char *__restrict, size_t, _mbstate_t *);
-int	wctomb (char *, wchar_t);
-int	_wctomb_r (struct _reent *, char *, wchar_t, _mbstate_t *);
-size_t	mbstowcs (wchar_t *__restrict, const char *__restrict, size_t);
-size_t	_mbstowcs_r (struct _reent *, wchar_t *__restrict, const char *__restrict, size_t, _mbstate_t *);
-size_t	wcstombs (char *__restrict, const wchar_t *__restrict, size_t);
-size_t	_wcstombs_r (struct _reent *, char *__restrict, const wchar_t *__restrict, size_t, _mbstate_t *);
-#ifndef _REENT_ONLY
-#if __BSD_VISIBLE || __POSIX_VISIBLE >= 200809
-char *	mkdtemp (char *);
-#endif
-#if __GNU_VISIBLE
-int	mkostemp (char *, int);
-int	mkostemps (char *, int, int);
-#endif
-#if __MISC_VISIBLE || __POSIX_VISIBLE >= 200112 || __XSI_VISIBLE >= 4
-int	mkstemp (char *);
-#endif
-#if __MISC_VISIBLE
-int	mkstemps (char *, int);
-#endif
-#if __BSD_VISIBLE || (__XSI_VISIBLE >= 4 && __POSIX_VISIBLE < 200112)
-char *	mktemp (char *) _ATTRIBUTE ((__deprecated__("the use of `mktemp' is dangerous; use `mkstemp' instead")));
-#endif
-#endif /* !_REENT_ONLY */
-char *	_mkdtemp_r (struct _reent *, char *);
-int	_mkostemp_r (struct _reent *, char *, int);
-int	_mkostemps_r (struct _reent *, char *, int, int);
-int	_mkstemp_r (struct _reent *, char *);
-int	_mkstemps_r (struct _reent *, char *, int);
-char *	_mktemp_r (struct _reent *, char *) _ATTRIBUTE ((__deprecated__("the use of `mktemp' is dangerous; use `mkstemp' instead")));
-void	qsort (void *__base, size_t __nmemb, size_t __size, __compar_fn_t _compar);
-int	rand (void);
-void	*realloc(void *, size_t) __result_use_check __alloc_size(2) _NOTHROW;
-#if __BSD_VISIBLE
-void	*reallocarray(void *, size_t, size_t) __result_use_check __alloc_size2(2, 3);
-void	*reallocf(void *, size_t) __result_use_check __alloc_size(2);
-#endif
-#if __BSD_VISIBLE || __XSI_VISIBLE >= 4
-char *	realpath (const char *__restrict path, char *__restrict resolved_path);
-#endif
-#if __BSD_VISIBLE
-int	rpmatch (const char *response);
-#endif
-#if __XSI_VISIBLE
-void	setkey (const char *__key);
-#endif
-void	srand (unsigned __seed);
-double	strtod (const char *__restrict __n, char **__restrict __end_PTR);
-double	_strtod_r (struct _reent *,const char *__restrict __n, char **__restrict __end_PTR);
-#if __ISO_C_VISIBLE >= 1999
-float	strtof (const char *__restrict __n, char **__restrict __end_PTR);
-#endif
-#if __MISC_VISIBLE
-/* the following strtodf interface is deprecated...use strtof instead */
-# ifndef strtodf
-#  define strtodf strtof
-# endif
-#endif
-long	strtol (const char *__restrict __n, char **__restrict __end_PTR, int __base);
-long	_strtol_r (struct _reent *,const char *__restrict __n, char **__restrict __end_PTR, int __base);
-unsigned long strtoul (const char *__restrict __n, char **__restrict __end_PTR, int __base);
-unsigned long _strtoul_r (struct _reent *,const char *__restrict __n, char **__restrict __end_PTR, int __base);
-
-#if __GNU_VISIBLE
-double	strtod_l (const char *__restrict, char **__restrict, locale_t);
-float	strtof_l (const char *__restrict, char **__restrict, locale_t);
-#ifdef _HAVE_LONG_DOUBLE
-extern long double strtold_l (const char *__restrict, char **__restrict,
-			      locale_t);
-#endif /* _HAVE_LONG_DOUBLE */
-long	strtol_l (const char *__restrict, char **__restrict, int, locale_t);
-unsigned long strtoul_l (const char *__restrict, char **__restrict, int,
-			 locale_t __loc);
-long long strtoll_l (const char *__restrict, char **__restrict, int, locale_t);
-unsigned long long strtoull_l (const char *__restrict, char **__restrict, int,
-			       locale_t __loc);
-#endif
-
-int	system (const char *__string);
-
-#if __SVID_VISIBLE || __XSI_VISIBLE >= 4
-long    a64l (const char *__input);
-char *  l64a (long __input);
-char *  _l64a_r (struct _reent *,long __input);
-#endif
-#if __MISC_VISIBLE
-int	on_exit (void (*__func)(int, void *),void *__arg);
-#endif
-#if __ISO_C_VISIBLE >= 1999
-void	_Exit (int __status) _ATTRIBUTE ((__noreturn__));
-#endif
-#if __SVID_VISIBLE || __XSI_VISIBLE
-int	putenv (char *__string);
-#endif
-int	_putenv_r (struct _reent *, char *__string);
-void *	_reallocf_r (struct _reent *, void *, size_t);
-#if __BSD_VISIBLE || __POSIX_VISIBLE >= 200112
-int	setenv (const char *__string, const char *__value, int __overwrite);
-#endif
-int	_setenv_r (struct _reent *, const char *__string, const char *__value, int __overwrite);
-
-#if __XSI_VISIBLE >= 4 && __POSIX_VISIBLE < 200112
-char *	gcvt (double,int,char *);
-char *	gcvtf (float,int,char *);
-char *	fcvt (double,int,int *,int *);
-char *	fcvtf (float,int,int *,int *);
-char *	ecvt (double,int,int *,int *);
-char *	ecvtbuf (double, int, int*, int*, char *);
-char *	fcvtbuf (double, int, int*, int*, char *);
-char *	ecvtf (float,int,int *,int *);
-#endif
-char *	__itoa (int, char *, int);
-char *	__utoa (unsigned, char *, int);
-#if __MISC_VISIBLE
-char *	itoa (int, char *, int);
-char *	utoa (unsigned, char *, int);
-#endif
-#if __POSIX_VISIBLE
-int	rand_r (unsigned *__seed);
-#endif
-
-#if __SVID_VISIBLE || __XSI_VISIBLE
-double drand48 (void);
-double _drand48_r (struct _reent *);
-double erand48 (unsigned short [3]);
-double _erand48_r (struct _reent *, unsigned short [3]);
-long   jrand48 (unsigned short [3]);
-long   _jrand48_r (struct _reent *, unsigned short [3]);
-void  lcong48 (unsigned short [7]);
-void  _lcong48_r (struct _reent *, unsigned short [7]);
-long   lrand48 (void);
-long   _lrand48_r (struct _reent *);
-long   mrand48 (void);
-long   _mrand48_r (struct _reent *);
-long   nrand48 (unsigned short [3]);
-long   _nrand48_r (struct _reent *, unsigned short [3]);
-unsigned short *
-       seed48 (unsigned short [3]);
-unsigned short *
-       _seed48_r (struct _reent *, unsigned short [3]);
-void  srand48 (long);
-void  _srand48_r (struct _reent *, long);
-#endif /* __SVID_VISIBLE || __XSI_VISIBLE */
-#if __SVID_VISIBLE || __XSI_VISIBLE >= 4 || __BSD_VISIBLE
-char *	initstate (unsigned, char *, size_t);
-long	random (void);
-char *	setstate (char *);
-void	srandom (unsigned);
-#endif
-#if __ISO_C_VISIBLE >= 1999
-long long atoll (const char *__nptr);
-#endif
-long long _atoll_r (struct _reent *, const char *__nptr);
-#if __ISO_C_VISIBLE >= 1999
-long long llabs (long long);
-lldiv_t	lldiv (long long __numer, long long __denom);
-long long strtoll (const char *__restrict __n, char **__restrict __end_PTR, int __base);
-#endif
-long long _strtoll_r (struct _reent *, const char *__restrict __n, char **__restrict __end_PTR, int __base);
-#if __ISO_C_VISIBLE >= 1999
-unsigned long long strtoull (const char *__restrict __n, char **__restrict __end_PTR, int __base);
-#endif
-unsigned long long _strtoull_r (struct _reent *, const char *__restrict __n, char **__restrict __end_PTR, int __base);
-
-#ifndef __CYGWIN__
-#if __MISC_VISIBLE
-void	cfree (void *);
-#endif
-#if __BSD_VISIBLE || __POSIX_VISIBLE >= 200112
-int	unsetenv (const char *__string);
-#endif
-int	_unsetenv_r (struct _reent *, const char *__string);
-#endif /* !__CYGWIN__ */
-
-#if __POSIX_VISIBLE >= 200112
-int	posix_memalign (void **, size_t, size_t) __nonnull((1))
-	    __result_use_check;
-#endif
-
-char *	_dtoa_r (struct _reent *, double, int, int, int *, int*, char**);
-#ifndef __CYGWIN__
-void *	_malloc_r (struct _reent *, size_t) _NOTHROW;
-void *	_calloc_r (struct _reent *, size_t, size_t) _NOTHROW;
-void	_free_r (struct _reent *, void *) _NOTHROW;
-void *	_realloc_r (struct _reent *, void *, size_t) _NOTHROW;
-void	_mstats_r (struct _reent *, char *);
-#endif
-int	_system_r (struct _reent *, const char *);
-
-void	__eprintf (const char *, const char *, unsigned int, const char *);
-
-/* There are two common qsort_r variants.  If you request
-   _BSD_SOURCE, you get the BSD version; otherwise you get the GNU
-   version.  We want that #undef qsort_r will still let you
-   invoke the underlying function, but that requires gcc support. */
-#if __GNU_VISIBLE
-void	qsort_r (void *__base, size_t __nmemb, size_t __size, int (*_compar)(const void *, const void *, void *), void *__thunk);
-#elif __BSD_VISIBLE
-# ifdef __GNUC__
-void	qsort_r (void *__base, size_t __nmemb, size_t __size, void *__thunk, int (*_compar)(void *, const void *, const void *))
-             __asm__ (__ASMNAME ("__bsd_qsort_r"));
-# else
-void	__bsd_qsort_r (void *__base, size_t __nmemb, size_t __size, void *__thunk, int (*_compar)(void *, const void *, const void *));
-#  define qsort_r __bsd_qsort_r
-# endif
-#endif
-
-/* On platforms where long double equals double.  */
-#ifdef _HAVE_LONG_DOUBLE
-extern long double _strtold_r (struct _reent *, const char *__restrict, char **__restrict);
-#if __ISO_C_VISIBLE >= 1999
-extern long double strtold (const char *__restrict, char **__restrict);
-#endif
-#endif /* _HAVE_LONG_DOUBLE */
-
-/*
- * If we're in a mode greater than C99, expose C11 functions.
- */
-#if __ISO_C_VISIBLE >= 2011
-void *	aligned_alloc(size_t, size_t) __malloc_like __alloc_align(1)
-	    __alloc_size(2) __result_use_check;
-int	at_quick_exit(void (*)(void));
-_Noreturn void
-	quick_exit(int);
-#endif /* __ISO_C_VISIBLE >= 2011 */
-
-_END_STD_C
-
-#if __SSP_FORTIFY_LEVEL > 0
-#include <ssp/stdlib.h>
-#endif
-
-#endif /* _STDLIB_H_ */

src/include/string.h

@@ -1,183 +0,0 @@
-/*
- * string.h
- *
- * Definitions for memory and string functions.
- */
-
-#ifndef _STRING_H_
-#define	_STRING_H_
-
-#include "_ansi.h"
-#include <sys/reent.h>
-#include <sys/cdefs.h>
-#include <sys/features.h>
-
-#define __need_size_t
-#define __need_NULL
-#include <stddef.h>
-
-#if __POSIX_VISIBLE >= 200809
-#include <xlocale.h>
-#endif
-
-#if __BSD_VISIBLE
-#include <strings.h>
-#endif
-
-_BEGIN_STD_C
-
-void *	 memchr (const void *, int, size_t);
-int 	 memcmp (const void *, const void *, size_t);
-void *	 memcpy (void *__restrict, const void *__restrict, size_t);
-void *	 memmove (void *, const void *, size_t);
-void *	 memset (void *, int, size_t);
-char 	*strcat (char *__restrict, const char *__restrict);
-char 	*strchr (const char *, int);
-int	 strcmp (const char *, const char *);
-int	 strcoll (const char *, const char *);
-char 	*strcpy (char *__restrict, const char *__restrict);
-size_t	 strcspn (const char *, const char *);
-char 	*strerror (int);
-size_t	 strlen (const char *);
-char 	*strncat (char *__restrict, const char *__restrict, size_t);
-int	 strncmp (const char *, const char *, size_t);
-char 	*strncpy (char *__restrict, const char *__restrict, size_t);
-char 	*strpbrk (const char *, const char *);
-char 	*strrchr (const char *, int);
-size_t	 strspn (const char *, const char *);
-char 	*strstr (const char *, const char *);
-#ifndef _REENT_ONLY
-char 	*strtok (char *__restrict, const char *__restrict);
-#endif
-size_t	 strxfrm (char *__restrict, const char *__restrict, size_t);
-
-#if __POSIX_VISIBLE >= 200809
-int	 strcoll_l (const char *, const char *, locale_t);
-char	*strerror_l (int, locale_t);
-size_t	 strxfrm_l (char *__restrict, const char *__restrict, size_t, locale_t);
-#endif
-#if __MISC_VISIBLE || __POSIX_VISIBLE
-char 	*strtok_r (char *__restrict, const char *__restrict, char **__restrict);
-#endif
-#if __BSD_VISIBLE
-int	 timingsafe_bcmp (const void *, const void *, size_t);
-int	 timingsafe_memcmp (const void *, const void *, size_t);
-#endif
-#if __MISC_VISIBLE || __POSIX_VISIBLE
-void *	 memccpy (void *__restrict, const void *__restrict, int, size_t);
-#endif
-#if __GNU_VISIBLE
-void *	 mempcpy (void *, const void *, size_t);
-void *	 memmem (const void *, size_t, const void *, size_t);
-void *	 memrchr (const void *, int, size_t);
-void *	 rawmemchr (const void *, int);
-#endif
-#if __POSIX_VISIBLE >= 200809
-char 	*stpcpy (char *__restrict, const char *__restrict);
-char 	*stpncpy (char *__restrict, const char *__restrict, size_t);
-#endif
-#if __GNU_VISIBLE
-char	*strcasestr (const char *, const char *);
-char 	*strchrnul (const char *, int);
-#endif
-#if __MISC_VISIBLE || __POSIX_VISIBLE >= 200809 || __XSI_VISIBLE >= 4
-char 	*strdup (const char *) __malloc_like __result_use_check;
-#endif
-char 	*_strdup_r (struct _reent *, const char *);
-#if __POSIX_VISIBLE >= 200809
-char 	*strndup (const char *, size_t) __malloc_like __result_use_check;
-#endif
-char 	*_strndup_r (struct _reent *, const char *, size_t);
-
-/* There are two common strerror_r variants.  If you request
-   _GNU_SOURCE, you get the GNU version; otherwise you get the POSIX
-   version.  POSIX requires that #undef strerror_r will still let you
-   invoke the underlying function, but that requires gcc support.  */
-#if __GNU_VISIBLE
-char	*strerror_r (int, char *, size_t);
-#elif __POSIX_VISIBLE >= 200112
-# ifdef __GNUC__
-int	strerror_r (int, char *, size_t)
-#ifdef __ASMNAME
-             __asm__ (__ASMNAME ("__xpg_strerror_r"))
-#endif
-  ;
-# else
-int	__xpg_strerror_r (int, char *, size_t);
-#  define strerror_r __xpg_strerror_r
-# endif
-#endif
-
-/* Reentrant version of strerror.  */
-char *	_strerror_r (struct _reent *, int, int, int *);
-
-#if __BSD_VISIBLE
-size_t	strlcat (char *, const char *, size_t);
-size_t	strlcpy (char *, const char *, size_t);
-#endif
-#if __POSIX_VISIBLE >= 200809
-size_t	 strnlen (const char *, size_t);
-#endif
-#if __BSD_VISIBLE
-char 	*strsep (char **, const char *);
-#endif
-#if __BSD_VISIBLE
-char    *strnstr(const char *, const char *, size_t) __pure;
-#endif
-
-#if __MISC_VISIBLE
-char	*strlwr (char *);
-char	*strupr (char *);
-#endif
-
-#ifndef DEFS_H	/* Kludge to work around problem compiling in gdb */
-char	*strsignal (int __signo);
-#endif
-
-#ifdef __CYGWIN__
-int	strtosigno (const char *__name);
-#endif
-
-#if __GNU_VISIBLE
-int	 strverscmp (const char *, const char *);
-#endif
-
-#if __GNU_VISIBLE && defined(__GNUC__)
-#define strdupa(__s) \
-	(__extension__ ({const char *__sin = (__s); \
-			 size_t __len = strlen (__sin) + 1; \
-			 char * __sout = (char *) __builtin_alloca (__len); \
-			 (char *) memcpy (__sout, __sin, __len);}))
-#define strndupa(__s, __n) \
-	(__extension__ ({const char *__sin = (__s); \
-			 size_t __len = strnlen (__sin, (__n)) + 1; \
-			 char *__sout = (char *) __builtin_alloca (__len); \
-			 __sout[__len-1] = '\0'; \
-			 (char *) memcpy (__sout, __sin, __len-1);}))
-#endif /* __GNU_VISIBLE && __GNUC__ */
-
-/* There are two common basename variants.  If you do NOT #include <libgen.h>
-   and you do
-
-     #define _GNU_SOURCE
-     #include <string.h>
-
-   you get the GNU version.  Otherwise you get the POSIX versionfor which you
-   should #include <libgen.h>i for the function prototype.  POSIX requires that
-   #undef basename will still let you invoke the underlying function.  However,
-   this also implies that the POSIX version is used in this case.  That's made
-   sure here. */
-#if __GNU_VISIBLE && !defined(basename)
-# define basename basename
-char	*__nonnull ((1)) basename (const char *) __asm__(__ASMNAME("__gnu_basename"));
-#endif
-
-#include <sys/string.h>
-
-_END_STD_C
-
-#if __SSP_FORTIFY_LEVEL > 0
-#include <ssp/string.h>
-#endif
-
-#endif /* _STRING_H_ */

src/include/strings.h

@@ -1,80 +0,0 @@
-/*-
- * Copyright (c) 2002 Mike Barcroft <mike@FreeBSD.org>
- * All rights reserved.
- *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions
- * are met:
- * 1. Redistributions of source code must retain the above copyright
- *    notice, this list of conditions and the following disclaimer.
- * 2. Redistributions in binary form must reproduce the above copyright
- *    notice, this list of conditions and the following disclaimer in the
- *    documentation and/or other materials provided with the distribution.
- *
- * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
- * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
- * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
- * ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
- * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
- * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
- * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
- * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
- * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
- * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
- * SUCH DAMAGE.
- *
- * $FreeBSD: head/include/strings.h 272673 2014-10-07 04:54:11Z delphij $
- */
-
-#ifndef _STRINGS_H_
-#define	_STRINGS_H_
-
-#include <sys/cdefs.h>
-#include <sys/_types.h>
-
-#if __POSIX_VISIBLE >= 200809
-#include <xlocale.h>
-#endif
-
-#ifndef _SIZE_T_DECLARED
-typedef	__size_t	size_t;
-#define	_SIZE_T_DECLARED
-#endif
-
-__BEGIN_DECLS
-#if __BSD_VISIBLE || __POSIX_VISIBLE <= 200112
-int	 bcmp(const void *, const void *, size_t) __pure;	/* LEGACY */
-void	 bcopy(const void *, void *, size_t);			/* LEGACY */
-void	 bzero(void *, size_t);					/* LEGACY */
-#endif
-#if __BSD_VISIBLE
-void	 explicit_bzero(void *, size_t);
-#endif
-#if __MISC_VISIBLE || __POSIX_VISIBLE < 200809 || __XSI_VISIBLE >= 700
-int	 ffs(int) __pure2;
-#endif
-#if __BSD_VISIBLE
-int	 ffsl(long) __pure2;
-int	 ffsll(long long) __pure2;
-int	 fls(int) __pure2;
-int	 flsl(long) __pure2;
-int	 flsll(long long) __pure2;
-#endif
-#if __BSD_VISIBLE || __POSIX_VISIBLE <= 200112
-char	*index(const char *, int) __pure;			/* LEGACY */
-char	*rindex(const char *, int) __pure;			/* LEGACY */
-#endif
-int	 strcasecmp(const char *, const char *) __pure;
-int	 strncasecmp(const char *, const char *, size_t) __pure;
-
-#if __POSIX_VISIBLE >= 200809
-int	 strcasecmp_l (const char *, const char *, locale_t);
-int	 strncasecmp_l (const char *, const char *, size_t, locale_t);
-#endif
-__END_DECLS
-
-#if __SSP_FORTIFY_LEVEL > 0
-#include <ssp/strings.h>
-#endif
-
-#endif /* _STRINGS_H_ */

src/include/sys/_intsup.h

@@ -1,195 +0,0 @@
-/*
- * Copyright (c) 2004, 2005 by
- * Ralf Corsepius, Ulm/Germany. All rights reserved.
- *
- * Permission to use, copy, modify, and distribute this software
- * is freely granted, provided that this notice is preserved.
- */
-
-#ifndef _SYS__INTSUP_H
-#define _SYS__INTSUP_H
-
-#include <sys/features.h>
-
-#if __GNUC_PREREQ (3, 2)
-/* gcc > 3.2 implicitly defines the values we are interested */
-#define __STDINT_EXP(x) __##x##__
-#else
-#define __STDINT_EXP(x) x
-#include <limits.h>
-#endif
-
-/* Determine how intptr_t and intN_t fastN_t and leastN_t are defined by gcc
-   for this target.  This is used to determine the correct printf() constant in
-   inttypes.h and other  constants in stdint.h.
-   So we end up with
-   ?(signed|unsigned) char == 0
-   ?(signed|unsigned) short == 1
-   ?(signed|unsigned) int == 2
-   ?(signed|unsigned) short int == 3
-   ?(signed|unsigned) long == 4
-   ?(signed|unsigned) long int == 6
-   ?(signed|unsigned) long long == 8
-   ?(signed|unsigned) long long int == 10
- */
-#pragma push_macro("signed")
-#pragma push_macro("unsigned")
-#pragma push_macro("char")
-#pragma push_macro("short")
-#pragma push_macro("__int20")
-#pragma push_macro("int")
-#pragma push_macro("long")
-#undef signed
-#undef unsigned
-#undef char
-#undef short
-#undef int
-#undef __int20
-#undef long
-#define signed +0
-#define unsigned +0
-#define char +0
-#define short +1
-#define __int20 +2
-#define int +2
-#define long +4
-#if (__INTPTR_TYPE__ == 8 || __INTPTR_TYPE__ == 10)
-#define _INTPTR_EQ_LONGLONG
-#elif (__INTPTR_TYPE__ == 4 || __INTPTR_TYPE__ == 6)
-#define _INTPTR_EQ_LONG
-/* Note - the tests for _INTPTR_EQ_INT and _INTPTR_EQ_SHORT are currently
-   redundant as the values are not used.  But one day they may be needed
-   and so the tests remain.  */
-#elif __INTPTR_TYPE__ == 2
-#define _INTPTR_EQ_INT
-#elif (__INTPTR_TYPE__ == 1 || __INTPTR_TYPE__ == 3)
-#define _INTPTR_EQ_SHORT
-#else
-#error "Unable to determine type definition of intptr_t"
-#endif
-#if (__INT32_TYPE__ == 4 || __INT32_TYPE__ == 6)
-#define _INT32_EQ_LONG
-#elif __INT32_TYPE__ == 2
-/* Nothing to define because int32_t is safe to print as an int. */
-#else
-#error "Unable to determine type definition of int32_t"
-#endif
-
-#if (__INT8_TYPE__ == 0)
-#define __INT8 "hh"
-#elif (__INT8_TYPE__ == 1 || __INT8_TYPE__ == 3)
-#define __INT8 "h"
-#elif (__INT8_TYPE__ == 2)
-#define __INT8
-#elif (__INT8_TYPE__ == 4 || __INT8_TYPE__ == 6)
-#define __INT8 "l"
-#elif (__INT8_TYPE__ == 8 || __INT8_TYPE__ == 10)
-#define __INT8 "ll"
-#endif
-#if (__INT16_TYPE__ == 1 || __INT16_TYPE__ == 3)
-#define __INT16 "h"
-#elif (__INT16_TYPE__ == 2)
-#define __INT16
-#elif (__INT16_TYPE__ == 4 || __INT16_TYPE__ == 6)
-#define __INT16 "l"
-#elif (__INT16_TYPE__ == 8 || __INT16_TYPE__ == 10)
-#define __INT16 "ll"
-#endif
-#if (__INT32_TYPE__ == 2)
-#define __INT32
-#elif (__INT32_TYPE__ == 4 || __INT32_TYPE__ == 6)
-#define __INT32 "l"
-#elif (__INT32_TYPE__ == 8 || __INT32_TYPE__ == 10)
-#define __INT32 "ll"
-#endif
-#if (__INT64_TYPE__ == 2)
-#define __INT64
-#elif (__INT64_TYPE__ == 4 || __INT64_TYPE__ == 6)
-#define __INT64 "l"
-#elif (__INT64_TYPE__ == 8 || __INT64_TYPE__ == 10)
-#define __INT64 "ll"
-#endif
-#if (__INT_FAST8_TYPE__ == 0)
-#define __FAST8 "hh"
-#elif (__INT_FAST8_TYPE__ == 1 || __INT_FAST8_TYPE__ == 3)
-#define __FAST8 "h"
-#elif (__INT_FAST8_TYPE__ == 2)
-#define __FAST8
-#elif (__INT_FAST8_TYPE__ == 4 || __INT_FAST8_TYPE__ == 6)
-#define __FAST8 "l"
-#elif (__INT_FAST8_TYPE__ == 8 || __INT_FAST8_TYPE__ == 10)
-#define __FAST8 "ll"
-#endif
-#if (__INT_FAST16_TYPE__ == 1 || __INT_FAST16_TYPE__ == 3)
-#define __FAST16 "h"
-#elif (__INT_FAST16_TYPE__ == 2)
-#define __FAST16
-#elif (__INT_FAST16_TYPE__ == 4 || __INT_FAST16_TYPE__ == 6)
-#define __FAST16 "l"
-#elif (__INT_FAST16_TYPE__ == 8 || __INT_FAST16_TYPE__ == 10)
-#define __FAST16 "ll"
-#endif
-#if (__INT_FAST32_TYPE__ == 2)
-#define __FAST32
-#elif (__INT_FAST32_TYPE__ == 4 || __INT_FAST32_TYPE__ == 6)
-#define __FAST32 "l"
-#elif (__INT_FAST32_TYPE__ == 8 || __INT_FAST32_TYPE__ == 10)
-#define __FAST32 "ll"
-#endif
-#if (__INT_FAST64_TYPE__ == 2)
-#define __FAST64
-#elif (__INT_FAST64_TYPE__ == 4 || __INT_FAST64_TYPE__ == 6)
-#define __FAST64 "l"
-#elif (__INT_FAST64_TYPE__ == 8 || __INT_FAST64_TYPE__ == 10)
-#define __FAST64 "ll"
-#endif
-
-#if (__INT_LEAST8_TYPE__ == 0)
-#define __LEAST8 "hh"
-#elif (__INT_LEAST8_TYPE__ == 1 || __INT_LEAST8_TYPE__ == 3)
-#define __LEAST8 "h"
-#elif (__INT_LEAST8_TYPE__ == 2)
-#define __LEAST8
-#elif (__INT_LEAST8_TYPE__ == 4 || __INT_LEAST8_TYPE__ == 6)
-#define __LEAST8 "l"
-#elif (__INT_LEAST8_TYPE__ == 8 || __INT_LEAST8_TYPE__ == 10)
-#define __LEAST8 "ll"
-#endif
-#if (__INT_LEAST16_TYPE__ == 1 || __INT_LEAST16_TYPE__ == 3)
-#define __LEAST16 "h"
-#elif (__INT_LEAST16_TYPE__ == 2)
-#define __LEAST16
-#elif (__INT_LEAST16_TYPE__ == 4 || __INT_LEAST16_TYPE__ == 6)
-#define __LEAST16 "l"
-#elif (__INT_LEAST16_TYPE__ == 8 || __INT_LEAST16_TYPE__ == 10)
-#define __LEAST16 "ll"
-#endif
-#if (__INT_LEAST32_TYPE__ == 2)
-#define __LEAST32
-#elif (__INT_LEAST32_TYPE__ == 4 || __INT_LEAST32_TYPE__ == 6)
-#define __LEAST32 "l"
-#elif (__INT_LEAST32_TYPE__ == 8 || __INT_LEAST32_TYPE__ == 10)
-#define __LEAST32 "ll"
-#endif
-#if (__INT_LEAST64_TYPE__ == 2)
-#define __LEAST64
-#elif (__INT_LEAST64_TYPE__ == 4 || __INT_LEAST64_TYPE__ == 6)
-#define __LEAST64 "l"
-#elif (__INT_LEAST64_TYPE__ == 8 || __INT_LEAST64_TYPE__ == 10)
-#define __LEAST64 "ll"
-#endif
-#undef signed
-#undef unsigned
-#undef char
-#undef short
-#undef int
-#undef long
-#pragma pop_macro("signed")
-#pragma pop_macro("unsigned")
-#pragma pop_macro("char")
-#pragma pop_macro("short")
-#pragma pop_macro("__int20")
-#pragma pop_macro("int")
-#pragma pop_macro("long")
-
-#endif /* _SYS__INTSUP_H */

src/include/sys/_pthreadtypes.h

@@ -1,233 +0,0 @@
-/*
- *  Written by Joel Sherrill <joel.sherrill@OARcorp.com>.
- *
- *  COPYRIGHT (c) 1989-2013, 2015.
- *  On-Line Applications Research Corporation (OAR).
- *
- *  Permission to use, copy, modify, and distribute this software for any
- *  purpose without fee is hereby granted, provided that this entire notice
- *  is included in all copies of any software which is or includes a copy
- *  or modification of this software.
- *
- *  THIS SOFTWARE IS BEING PROVIDED "AS IS", WITHOUT ANY EXPRESS OR IMPLIED
- *  WARRANTY.  IN PARTICULAR,  THE AUTHOR MAKES NO REPRESENTATION
- *  OR WARRANTY OF ANY KIND CONCERNING THE MERCHANTABILITY OF THIS
- *  SOFTWARE OR ITS FITNESS FOR ANY PARTICULAR PURPOSE.
- */
-
-#ifndef _SYS__PTHREADTYPES_H_
-#define	_SYS__PTHREADTYPES_H_
-
-#if defined(_POSIX_THREADS) || __POSIX_VISIBLE >= 199506
-
-#include <sys/sched.h>
-
-/*
- *  2.5 Primitive System Data Types,  P1003.1c/D10, p. 19.
- */
-
-#if defined(__XMK__)
-typedef unsigned int pthread_t;          /* identify a thread */
-#else
-typedef __uint32_t pthread_t;            /* identify a thread */
-#endif
-
-/* P1003.1c/D10, p. 118-119 */
-#define PTHREAD_SCOPE_PROCESS 0
-#define PTHREAD_SCOPE_SYSTEM  1
-
-/* P1003.1c/D10, p. 111 */
-#define PTHREAD_INHERIT_SCHED  1      /* scheduling policy and associated */
-                                      /*   attributes are inherited from */
-                                      /*   the calling thread. */
-#define PTHREAD_EXPLICIT_SCHED 2      /* set from provided attribute object */
-
-/* P1003.1c/D10, p. 141 */
-#define PTHREAD_CREATE_DETACHED 0
-#define PTHREAD_CREATE_JOINABLE  1
-
-#if defined(__XMK__)
-typedef struct pthread_attr_s {
-  int contentionscope;
-  struct sched_param schedparam;
-  int  detachstate;
-  void *stackaddr;
-  size_t stacksize;
-} pthread_attr_t;
-
-#define PTHREAD_STACK_MIN       200
-
-#else /* !defined(__XMK__) */
-typedef struct {
-  int is_initialized;
-  void *stackaddr;
-  int stacksize;
-  int contentionscope;
-  int inheritsched;
-  int schedpolicy;
-  struct sched_param schedparam;
-
-  /* P1003.4b/D8, p. 54 adds cputime_clock_allowed attribute.  */
-#if defined(_POSIX_THREAD_CPUTIME)
-  int  cputime_clock_allowed;  /* see time.h */
-#endif
-  int  detachstate;
-} pthread_attr_t;
-
-#endif /* !defined(__XMK__) */
-
-#if defined(_POSIX_THREAD_PROCESS_SHARED)
-/* NOTE: P1003.1c/D10, p. 81 defines following values for process_shared.  */
-
-#define PTHREAD_PROCESS_PRIVATE 0 /* visible within only the creating process */
-#define PTHREAD_PROCESS_SHARED  1 /* visible too all processes with access to */
-                                  /*   the memory where the resource is */
-                                  /*   located */
-#endif
-
-#if defined(_POSIX_THREAD_PRIO_PROTECT)
-/* Mutexes */
-
-/* Values for blocking protocol. */
-
-#define PTHREAD_PRIO_NONE    0
-#define PTHREAD_PRIO_INHERIT 1
-#define PTHREAD_PRIO_PROTECT 2
-#endif
-
-#if defined(_UNIX98_THREAD_MUTEX_ATTRIBUTES)
-
-/* Values for mutex type */
-
-/* The following defines are part of the X/Open System Interface (XSI). */
-
-/*
- * This type of mutex does not detect deadlock. A thread attempting to
- * relock this mutex without first unlocking it shall deadlock. Attempting
- * to unlock a mutex locked by a different thread results in undefined
- * behavior.  Attempting to unlock an unlocked mutex results in undefined
- * behavior.
- */
-#define PTHREAD_MUTEX_NORMAL     0
-
-/*
- * A thread attempting to relock this mutex without first unlocking
- * it shall succeed in locking the mutex.  The relocking deadlock which
- * can occur with mutexes of type PTHREAD_MUTEX_NORMAL cannot occur with
- * this type of mutex.  Multiple locks of this mutex shall require the
- * same number of unlocks to release the mutex before another thread can
- * acquire the mutex. A thread attempting to unlock a mutex which another
- * thread has locked shall return with an error.  A thread attempting to
- * unlock an unlocked mutex shall return with an error.
- */
-#define PTHREAD_MUTEX_RECURSIVE  1
-
-/*
- * This type of mutex provides error checking. A thread attempting
- * to relock this mutex without first unlocking it shall return with an
- * error. A thread attempting to unlock a mutex which another thread has
- * locked shall return with an error. A thread attempting to unlock an
- * unlocked mutex shall return with an error.
- */
-#define PTHREAD_MUTEX_ERRORCHECK 2
-
-/*
- * Attempting to recursively lock a mutex of this type results
- * in undefined behavior. Attempting to unlock a mutex of this type
- * which was not locked by the calling thread results in undefined
- * behavior. Attempting to unlock a mutex of this type which is not locked
- * results in undefined behavior. An implementation may map this mutex to
- * one of the other mutex types.
- */
-#define PTHREAD_MUTEX_DEFAULT    3
-
-#endif /* !defined(_UNIX98_THREAD_MUTEX_ATTRIBUTES) */
-
-#if defined(__XMK__)
-typedef unsigned int pthread_mutex_t;    /* identify a mutex */
-
-typedef struct {
-  int type;
-} pthread_mutexattr_t;
-
-#else /* !defined(__XMK__) */
-typedef __uint32_t pthread_mutex_t;      /* identify a mutex */
-
-typedef struct {
-  int   is_initialized;
-#if defined(_POSIX_THREAD_PROCESS_SHARED)
-  int   process_shared;  /* allow mutex to be shared amongst processes */
-#endif
-#if defined(_POSIX_THREAD_PRIO_PROTECT)
-  int   prio_ceiling;
-  int   protocol;
-#endif
-#if defined(_UNIX98_THREAD_MUTEX_ATTRIBUTES)
-  int type;
-#endif
-  int   recursive;
-} pthread_mutexattr_t;
-#endif /* !defined(__XMK__) */
-
-#define _PTHREAD_MUTEX_INITIALIZER ((pthread_mutex_t) 0xFFFFFFFF)
-
-/* Condition Variables */
-
-typedef __uint32_t pthread_cond_t;       /* identify a condition variable */
-
-#define _PTHREAD_COND_INITIALIZER ((pthread_cond_t) 0xFFFFFFFF)
-
-typedef struct {
-  int      is_initialized;
-  clock_t  clock;             /* specifiy clock for timeouts */
-#if defined(_POSIX_THREAD_PROCESS_SHARED)
-  int      process_shared;    /* allow this to be shared amongst processes */
-#endif
-} pthread_condattr_t;         /* a condition attribute object */
-
-/* Keys */
-
-typedef __uint32_t pthread_key_t;        /* thread-specific data keys */
-
-typedef struct {
-  int   is_initialized;  /* is this structure initialized? */
-  int   init_executed;   /* has the initialization routine been run? */
-} pthread_once_t;       /* dynamic package initialization */
-
-#define _PTHREAD_ONCE_INIT  { 1, 0 }  /* is initialized and not run */
-#endif /* defined(_POSIX_THREADS) || __POSIX_VISIBLE >= 199506 */
-
-/* POSIX Barrier Types */
-
-#if defined(_POSIX_BARRIERS)
-typedef __uint32_t pthread_barrier_t;        /* POSIX Barrier Object */
-typedef struct {
-  int   is_initialized;  /* is this structure initialized? */
-#if defined(_POSIX_THREAD_PROCESS_SHARED)
-  int   process_shared;       /* allow this to be shared amongst processes */
-#endif
-} pthread_barrierattr_t;
-#endif /* defined(_POSIX_BARRIERS) */
-
-/* POSIX Spin Lock Types */
-
-#if defined(_POSIX_SPIN_LOCKS)
-typedef __uint32_t pthread_spinlock_t;        /* POSIX Spin Lock Object */
-#endif /* defined(_POSIX_SPIN_LOCKS) */
-
-/* POSIX Reader/Writer Lock Types */
-
-#if defined(_POSIX_READER_WRITER_LOCKS)
-typedef __uint32_t pthread_rwlock_t;         /* POSIX RWLock Object */
-
-#define _PTHREAD_RWLOCK_INITIALIZER ((pthread_rwlock_t) 0xFFFFFFFF)
-
-typedef struct {
-  int   is_initialized;       /* is this structure initialized? */
-#if defined(_POSIX_THREAD_PROCESS_SHARED)
-  int   process_shared;       /* allow this to be shared amongst processes */
-#endif
-} pthread_rwlockattr_t;
-#endif /* defined(_POSIX_READER_WRITER_LOCKS) */
-
-#endif /* ! _SYS__PTHREADTYPES_H_ */

src/include/sys/_sigset.h

@@ -1,43 +0,0 @@
-/*-
- * Copyright (c) 1982, 1986, 1989, 1991, 1993
- *	The Regents of the University of California.  All rights reserved.
- * (c) UNIX System Laboratories, Inc.
- * All or some portions of this file are derived from material licensed
- * to the University of California by American Telephone and Telegraph
- * Co. or Unix System Laboratories, Inc. and are reproduced herein with
- * the permission of UNIX System Laboratories, Inc.
- *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions
- * are met:
- * 1. Redistributions of source code must retain the above copyright
- *    notice, this list of conditions and the following disclaimer.
- * 2. Redistributions in binary form must reproduce the above copyright
- *    notice, this list of conditions and the following disclaimer in the
- *    documentation and/or other materials provided with the distribution.
- * 4. Neither the name of the University nor the names of its contributors
- *    may be used to endorse or promote products derived from this software
- *    without specific prior written permission.
- *
- * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
- * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
- * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
- * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
- * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
- * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
- * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
- * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
- * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
- * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
- * SUCH DAMAGE.
- *
- *	@(#)signal.h	8.4 (Berkeley) 5/4/95
- * $FreeBSD$
- */
-
-#ifndef _SYS__SIGSET_H_
-#define	_SYS__SIGSET_H_
-
-typedef unsigned long __sigset_t;
-
-#endif /* !_SYS__SIGSET_H_ */

src/include/sys/_stdint.h

@@ -1,90 +0,0 @@
-/*
- * Copyright (c) 2004, 2005 by
- * Ralf Corsepius, Ulm/Germany. All rights reserved.
- *
- * Permission to use, copy, modify, and distribute this software
- * is freely granted, provided that this notice is preserved.
- */
-
-#ifndef _SYS__STDINT_H
-#define _SYS__STDINT_H
-
-#include <machine/_default_types.h>
-
-#ifdef __cplusplus
-extern "C" {
-#endif
-
-#ifdef ___int8_t_defined
-#ifndef _INT8_T_DECLARED
-typedef __int8_t int8_t ;
-#define _INT8_T_DECLARED
-#endif
-#ifndef _UINT8_T_DECLARED
-typedef __uint8_t uint8_t ;
-#define _UINT8_T_DECLARED
-#endif
-#define __int8_t_defined 1
-#endif /* ___int8_t_defined */
-
-#ifdef ___int16_t_defined
-#ifndef _INT16_T_DECLARED
-typedef __int16_t int16_t ;
-#define _INT16_T_DECLARED
-#endif
-#ifndef _UINT16_T_DECLARED
-typedef __uint16_t uint16_t ;
-#define _UINT16_T_DECLARED
-#endif
-#define __int16_t_defined 1
-#endif /* ___int16_t_defined */
-
-#ifdef ___int32_t_defined
-#ifndef _INT32_T_DECLARED
-typedef __int32_t int32_t ;
-#define _INT32_T_DECLARED
-#endif
-#ifndef _UINT32_T_DECLARED
-typedef __uint32_t uint32_t ;
-#define _UINT32_T_DECLARED
-#endif
-#define __int32_t_defined 1
-#endif /* ___int32_t_defined */
-
-#ifdef ___int64_t_defined
-#ifndef _INT64_T_DECLARED
-typedef __int64_t int64_t ;
-#define _INT64_T_DECLARED
-#endif
-#ifndef _UINT64_T_DECLARED
-typedef __uint64_t uint64_t ;
-#define _UINT64_T_DECLARED
-#endif
-#define __int64_t_defined 1
-#endif /* ___int64_t_defined */
-
-#ifndef _INTMAX_T_DECLARED
-typedef __intmax_t intmax_t;
-#define _INTMAX_T_DECLARED
-#endif
-
-#ifndef _UINTMAX_T_DECLARED
-typedef __uintmax_t uintmax_t;
-#define _UINTMAX_T_DECLARED
-#endif
-
-#ifndef _INTPTR_T_DECLARED
-typedef __intptr_t intptr_t;
-#define _INTPTR_T_DECLARED
-#endif
-
-#ifndef _UINTPTR_T_DECLARED
-typedef __uintptr_t uintptr_t;
-#define _UINTPTR_T_DECLARED
-#endif
-
-#ifdef __cplusplus
-}
-#endif
-
-#endif /* _SYS__STDINT_H */

src/include/sys/_timespec.h

@@ -1,50 +0,0 @@
-/*-
- * Copyright (c) 1982, 1986, 1993
- *	The Regents of the University of California.  All rights reserved.
- *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions
- * are met:
- * 1. Redistributions of source code must retain the above copyright
- *    notice, this list of conditions and the following disclaimer.
- * 2. Redistributions in binary form must reproduce the above copyright
- *    notice, this list of conditions and the following disclaimer in the
- *    documentation and/or other materials provided with the distribution.
- * 4. Neither the name of the University nor the names of its contributors
- *    may be used to endorse or promote products derived from this software
- *    without specific prior written permission.
- *
- * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
- * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
- * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
- * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
- * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
- * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
- * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
- * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
- * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
- * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
- * SUCH DAMAGE.
- *
- *	@(#)time.h	8.5 (Berkeley) 5/4/95
- * from: FreeBSD: src/sys/sys/time.h,v 1.43 2000/03/20 14:09:05 phk Exp
- *	$FreeBSD$
- */
-
-#ifndef _SYS__TIMESPEC_H_
-#define	_SYS__TIMESPEC_H_
-
-#include <sys/_types.h>
-
-#if !defined(__time_t_defined) && !defined(_TIME_T_DECLARED)
-typedef	_TIME_T_	time_t;
-#define	__time_t_defined
-#define	_TIME_T_DECLARED
-#endif
-
-struct timespec {
-	time_t	tv_sec;		/* seconds */
-	long	tv_nsec;	/* and nanoseconds */
-};
-
-#endif /* !_SYS__TIMESPEC_H_ */

src/include/sys/_timeval.h

@@ -1,89 +0,0 @@
-/*-
- * Copyright (c) 2002 Mike Barcroft <mike@FreeBSD.org>
- * All rights reserved.
- *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions
- * are met:
- * 1. Redistributions of source code must retain the above copyright
- *    notice, this list of conditions and the following disclaimer.
- * 2. Redistributions in binary form must reproduce the above copyright
- *    notice, this list of conditions and the following disclaimer in the
- *    documentation and/or other materials provided with the distribution.
- *
- * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
- * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
- * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
- * ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
- * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
- * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
- * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
- * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
- * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
- * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
- * SUCH DAMAGE.
- *
- * $FreeBSD$
- */
-
-#ifndef _SYS__TIMEVAL_H_
-#define _SYS__TIMEVAL_H_
-
-#include <sys/_types.h>
-
-#ifndef _SUSECONDS_T_DECLARED
-typedef	__suseconds_t	suseconds_t;
-#define	_SUSECONDS_T_DECLARED
-#endif
-
-#if !defined(__time_t_defined) && !defined(_TIME_T_DECLARED)
-typedef	_TIME_T_	time_t;
-#define	__time_t_defined
-#define	_TIME_T_DECLARED
-#endif
-
-/* This define is also used outside of Newlib, e.g. in MinGW-w64 */
-#ifndef _TIMEVAL_DEFINED
-#define _TIMEVAL_DEFINED
-
-/*
- * Structure returned by gettimeofday(2) system call, and used in other calls.
- */
-struct timeval {
-	time_t		tv_sec;		/* seconds */
-	suseconds_t	tv_usec;	/* and microseconds */
-};
-
-#if __BSD_VISIBLE
-#ifndef _KERNEL			/* NetBSD/OpenBSD compatible interfaces */
-
-#define	timerclear(tvp)		((tvp)->tv_sec = (tvp)->tv_usec = 0)
-#define	timerisset(tvp)		((tvp)->tv_sec || (tvp)->tv_usec)
-#define	timercmp(tvp, uvp, cmp)					\
-	(((tvp)->tv_sec == (uvp)->tv_sec) ?				\
-	    ((tvp)->tv_usec cmp (uvp)->tv_usec) :			\
-	    ((tvp)->tv_sec cmp (uvp)->tv_sec))
-#define	timeradd(tvp, uvp, vvp)						\
-	do {								\
-		(vvp)->tv_sec = (tvp)->tv_sec + (uvp)->tv_sec;		\
-		(vvp)->tv_usec = (tvp)->tv_usec + (uvp)->tv_usec;	\
-		if ((vvp)->tv_usec >= 1000000) {			\
-			(vvp)->tv_sec++;				\
-			(vvp)->tv_usec -= 1000000;			\
-		}							\
-	} while (0)
-#define	timersub(tvp, uvp, vvp)						\
-	do {								\
-		(vvp)->tv_sec = (tvp)->tv_sec - (uvp)->tv_sec;		\
-		(vvp)->tv_usec = (tvp)->tv_usec - (uvp)->tv_usec;	\
-		if ((vvp)->tv_usec < 0) {				\
-			(vvp)->tv_sec--;				\
-			(vvp)->tv_usec += 1000000;			\
-		}							\
-	} while (0)
-#endif
-#endif /* __BSD_VISIBLE */
-
-#endif /* _TIMEVAL_DEFINED */
-
-#endif /* !_SYS__TIMEVAL_H_ */

src/include/sys/_types.h

@@ -1,224 +0,0 @@
-/* ANSI C namespace clean utility typedefs */
-
-/* This file defines various typedefs needed by the system calls that support
-   the C library.  Basically, they're just the POSIX versions with an '_'
-   prepended.  Targets shall use <machine/_types.h> to define their own
-   internal types if desired.
-
-   There are three define patterns used for type definitions.  Lets assume
-   xyz_t is a user type.
-
-   The internal type definition uses __machine_xyz_t_defined.  It is defined by
-   <machine/_types.h> to disable a default definition in <sys/_types.h>. It
-   must not be used in other files.
-
-   User type definitions are guarded by __xyz_t_defined in glibc and
-   _XYZ_T_DECLARED in BSD compatible systems.
-*/
-
-#ifndef	_SYS__TYPES_H
-#define _SYS__TYPES_H
-
-#include <newlib.h>
-#include <sys/config.h>
-#include <machine/_types.h>
-#include <sys/lock.h>
-
-#ifndef __machine_blkcnt_t_defined
-typedef long __blkcnt_t;
-#endif
-
-#ifndef __machine_blksize_t_defined
-typedef long __blksize_t;
-#endif
-
-#ifndef __machine_fsblkcnt_t_defined
-typedef __uint64_t __fsblkcnt_t;
-#endif
-
-#ifndef __machine_fsfilcnt_t_defined
-typedef __uint32_t __fsfilcnt_t;
-#endif
-
-#ifndef __machine_off_t_defined
-typedef long _off_t;
-#endif
-
-#if defined(__XMK__)
-typedef signed char __pid_t;
-#else
-typedef int __pid_t;
-#endif
-
-#ifndef __machine_dev_t_defined
-typedef short __dev_t;
-#endif
-
-#ifndef __machine_uid_t_defined
-typedef unsigned short __uid_t;
-#endif
-#ifndef __machine_gid_t_defined
-typedef unsigned short __gid_t;
-#endif
-
-#ifndef __machine_id_t_defined
-typedef __uint32_t __id_t;
-#endif
-
-#ifndef __machine_ino_t_defined
-#if (defined(__i386__) && (defined(GO32) || defined(__MSDOS__))) || \
-    defined(__sparc__) || defined(__SPU__)
-typedef unsigned long __ino_t;
-#else
-typedef unsigned short __ino_t;
-#endif
-#endif
-
-#ifndef __machine_mode_t_defined
-#if defined(__i386__) && (defined(GO32) || defined(__MSDOS__))
-typedef int __mode_t;
-#else
-#if defined(__sparc__) && !defined(__sparc_v9__)
-#ifdef __svr4__
-typedef unsigned long __mode_t;
-#else
-typedef unsigned short __mode_t;
-#endif
-#else
-typedef __uint32_t __mode_t;
-#endif
-#endif
-#endif
-
-#ifndef __machine_off64_t_defined
-__extension__ typedef long long _off64_t;
-#endif
-
-#if defined(__CYGWIN__) && !defined(__LP64__)
-typedef _off64_t __off_t;
-#else
-typedef _off_t __off_t;
-#endif
-
-typedef _off64_t __loff_t;
-
-#ifndef __machine_key_t_defined
-typedef long __key_t;
-#endif
-
-/*
- * We need fpos_t for the following, but it doesn't have a leading "_",
- * so we use _fpos_t instead.
- */
-#ifndef __machine_fpos_t_defined
-typedef long _fpos_t;		/* XXX must match off_t in <sys/types.h> */
-				/* (and must be `long' for now) */
-#endif
-
-#ifdef __LARGE64_FILES
-#ifndef __machine_fpos64_t_defined
-typedef _off64_t _fpos64_t;
-#endif
-#endif
-
-/* Defined by GCC provided <stddef.h> */
-#undef __size_t
-
-#ifndef __machine_size_t_defined
-#ifdef __SIZE_TYPE__
-typedef __SIZE_TYPE__ __size_t;
-#else
-#if defined(__INT_MAX__) && __INT_MAX__ == 2147483647
-typedef unsigned int __size_t;
-#else
-typedef unsigned long __size_t;
-#endif
-#endif
-#endif
-
-#ifndef __machine_ssize_t_defined
-#ifdef __SIZE_TYPE__
-/* If __SIZE_TYPE__ is defined (gcc) we define ssize_t based on size_t.
-   We simply change "unsigned" to "signed" for this single definition
-   to make sure ssize_t and size_t only differ by their signedness. */
-#define unsigned signed
-typedef __SIZE_TYPE__ _ssize_t;
-#undef unsigned
-#else
-#if defined(__INT_MAX__) && __INT_MAX__ == 2147483647
-typedef int _ssize_t;
-#else
-typedef long _ssize_t;
-#endif
-#endif
-#endif
-
-typedef _ssize_t __ssize_t;
-
-#define __need_wint_t
-#include <stddef.h>
-
-#ifndef __machine_mbstate_t_defined
-/* Conversion state information.  */
-typedef struct
-{
-  int __count;
-  union
-  {
-    wint_t __wch;
-    unsigned char __wchb[4];
-  } __value;		/* Value so far.  */
-} _mbstate_t;
-#endif
-
-#ifndef __machine_flock_t_defined
-typedef _LOCK_RECURSIVE_T _flock_t;
-#endif
-
-#ifndef __machine_iconv_t_defined
-/* Iconv descriptor type */
-typedef void *_iconv_t;
-#endif
-
-#ifndef __machine_clock_t_defined
-#define	_CLOCK_T_	unsigned long	/* clock() */
-#endif
-
-typedef	_CLOCK_T_	__clock_t;
-
-#if defined(_USE_LONG_TIME_T) || __LONG_MAX__ > 0x7fffffffL
-#define	_TIME_T_ long
-#else
-#define	_TIME_T_ __int_least64_t
-#endif
-typedef	_TIME_T_	__time_t;
-
-#ifndef __machine_clockid_t_defined
-#define	_CLOCKID_T_ 	unsigned long
-#endif
-
-typedef	_CLOCKID_T_	__clockid_t;
-
-#define	_TIMER_T_	unsigned long
-typedef	_TIMER_T_	__timer_t;
-
-#ifndef __machine_sa_family_t_defined
-typedef	__uint8_t	__sa_family_t;
-#endif
-
-#ifndef __machine_socklen_t_defined
-typedef	__uint32_t	__socklen_t;
-#endif
-
-typedef	int		__nl_item;
-typedef	unsigned short	__nlink_t;
-typedef	long		__suseconds_t;	/* microseconds (signed) */
-typedef	unsigned long	__useconds_t;	/* microseconds (unsigned) */
-
-#ifdef __GNUCLIKE_BUILTIN_VARARGS
-typedef	__builtin_va_list	__va_list;
-#else
-typedef	char *			__va_list;
-#endif /* __GNUCLIKE_BUILTIN_VARARGS */
-
-#endif	/* _SYS__TYPES_H */

src/include/sys/cdefs.h

@@ -1,716 +0,0 @@
-/* libc/sys/linux/sys/cdefs.h - Helper macros for K&R vs. ANSI C compat. */
-
-/* Written 2000 by Werner Almesberger */
-
-/*-
- * SPDX-License-Identifier: BSD-3-Clause
- *
- * Copyright (c) 1991, 1993
- *	The Regents of the University of California.  All rights reserved.
- *
- * This code is derived from software contributed to Berkeley by
- * Berkeley Software Design, Inc.
- *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions
- * are met:
- * 1. Redistributions of source code must retain the above copyright
- *    notice, this list of conditions and the following disclaimer.
- * 2. Redistributions in binary form must reproduce the above copyright
- *    notice, this list of conditions and the following disclaimer in the
- *    documentation and/or other materials provided with the distribution.
- * 3. Neither the name of the University nor the names of its contributors
- *    may be used to endorse or promote products derived from this software
- *    without specific prior written permission.
- *
- * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
- * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
- * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
- * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
- * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
- * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
- * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
- * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
- * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
- * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
- * SUCH DAMAGE.
- *
- *	@(#)cdefs.h	8.8 (Berkeley) 1/9/95
- * $FreeBSD$
- */
-
-#ifndef	_SYS_CDEFS_H_
-#define	_SYS_CDEFS_H_
-
-#include <machine/_default_types.h>
-#include <sys/features.h>
-#include <stddef.h>
-
-#define __PMT(args)	args
-#define __DOTS    	, ...
-#define __THROW
-
-#ifdef __GNUC__
-# define __ASMNAME(cname)  __XSTRING (__USER_LABEL_PREFIX__) cname
-#endif
-
-#define __ptr_t void *
-#define __long_double_t  long double
-
-#define __attribute_malloc__
-#define __attribute_pure__
-#define __attribute_format_strfmon__(a,b)
-#define __flexarr      [0]
-
-#ifndef __BOUNDED_POINTERS__
-# define __bounded      /* nothing */
-# define __unbounded    /* nothing */
-# define __ptrvalue     /* nothing */
-#endif
-
-/*
- * Testing against Clang-specific extensions.
- */
-#ifndef	__has_attribute
-#define	__has_attribute(x)	0
-#endif
-#ifndef	__has_extension
-#define	__has_extension		__has_feature
-#endif
-#ifndef	__has_feature
-#define	__has_feature(x)	0
-#endif
-#ifndef	__has_include
-#define	__has_include(x)	0
-#endif
-#ifndef	__has_builtin
-#define	__has_builtin(x)	0
-#endif
-
-#if defined(__cplusplus)
-#define	__BEGIN_DECLS	extern "C" {
-#define	__END_DECLS	}
-#else
-#define	__BEGIN_DECLS
-#define	__END_DECLS
-#endif
-
-/*
- * This code has been put in place to help reduce the addition of
- * compiler specific defines in FreeBSD code.  It helps to aid in
- * having a compiler-agnostic source tree.
- */
-
-#if defined(__GNUC__) || defined(__INTEL_COMPILER)
-
-#if __GNUC__ >= 3 || defined(__INTEL_COMPILER)
-#define	__GNUCLIKE_ASM 3
-#define	__GNUCLIKE_MATH_BUILTIN_CONSTANTS
-#else
-#define	__GNUCLIKE_ASM 2
-#endif
-#define	__GNUCLIKE___TYPEOF 1
-#define	__GNUCLIKE___OFFSETOF 1
-#define	__GNUCLIKE___SECTION 1
-
-#ifndef __INTEL_COMPILER
-#define	__GNUCLIKE_CTOR_SECTION_HANDLING 1
-#endif
-
-#define	__GNUCLIKE_BUILTIN_CONSTANT_P 1
-#if defined(__INTEL_COMPILER) && defined(__cplusplus) && \
-   __INTEL_COMPILER < 800
-#undef __GNUCLIKE_BUILTIN_CONSTANT_P
-#endif
-
-#if (__GNUC_MINOR__ > 95 || __GNUC__ >= 3)
-#define	__GNUCLIKE_BUILTIN_VARARGS 1
-#define	__GNUCLIKE_BUILTIN_STDARG 1
-#define	__GNUCLIKE_BUILTIN_VAALIST 1
-#endif
-
-#if defined(__GNUC__)
-#define	__GNUC_VA_LIST_COMPATIBILITY 1
-#endif
-
-/*
- * Compiler memory barriers, specific to gcc and clang.
- */
-#if defined(__GNUC__)
-#define	__compiler_membar()	__asm __volatile(" " : : : "memory")
-#endif
-
-#ifndef __INTEL_COMPILER
-#define	__GNUCLIKE_BUILTIN_NEXT_ARG 1
-#define	__GNUCLIKE_MATH_BUILTIN_RELOPS
-#endif
-
-#define	__GNUCLIKE_BUILTIN_MEMCPY 1
-
-/* XXX: if __GNUC__ >= 2: not tested everywhere originally, where replaced */
-#define	__CC_SUPPORTS_INLINE 1
-#define	__CC_SUPPORTS___INLINE 1
-#define	__CC_SUPPORTS___INLINE__ 1
-
-#define	__CC_SUPPORTS___FUNC__ 1
-#define	__CC_SUPPORTS_WARNING 1
-
-#define	__CC_SUPPORTS_VARADIC_XXX 1 /* see varargs.h */
-
-#define	__CC_SUPPORTS_DYNAMIC_ARRAY_INIT 1
-
-#endif /* __GNUC__ || __INTEL_COMPILER */
-
-/*
- * The __CONCAT macro is used to concatenate parts of symbol names, e.g.
- * with "#define OLD(foo) __CONCAT(old,foo)", OLD(foo) produces oldfoo.
- * The __CONCAT macro is a bit tricky to use if it must work in non-ANSI
- * mode -- there must be no spaces between its arguments, and for nested
- * __CONCAT's, all the __CONCAT's must be at the left.  __CONCAT can also
- * concatenate double-quoted strings produced by the __STRING macro, but
- * this only works with ANSI C.
- *
- * __XSTRING is like __STRING, but it expands any macros in its argument
- * first.  It is only available with ANSI C.
- */
-#if defined(__STDC__) || defined(__cplusplus)
-#define	__P(protos)	protos		/* full-blown ANSI C */
-#define	__CONCAT1(x,y)	x ## y
-#define	__CONCAT(x,y)	__CONCAT1(x,y)
-#define	__STRING(x)	#x		/* stringify without expanding x */
-#define	__XSTRING(x)	__STRING(x)	/* expand x, then stringify */
-
-#define	__const		const		/* define reserved names to standard */
-#define	__signed	signed
-#define	__volatile	volatile
-#if defined(__cplusplus)
-#define	__inline	inline		/* convert to C++ keyword */
-#else
-#if !(defined(__CC_SUPPORTS___INLINE))
-#define	__inline			/* delete GCC keyword */
-#endif /* ! __CC_SUPPORTS___INLINE */
-#endif /* !__cplusplus */
-
-#else	/* !(__STDC__ || __cplusplus) */
-#define	__P(protos)	()		/* traditional C preprocessor */
-#define	__CONCAT(x,y)	x/**/y
-#define	__STRING(x)	"x"
-
-#if !defined(__CC_SUPPORTS___INLINE)
-#define	__const				/* delete pseudo-ANSI C keywords */
-#define	__inline
-#define	__signed
-#define	__volatile
-/*
- * In non-ANSI C environments, new programs will want ANSI-only C keywords
- * deleted from the program and old programs will want them left alone.
- * When using a compiler other than gcc, programs using the ANSI C keywords
- * const, inline etc. as normal identifiers should define -DNO_ANSI_KEYWORDS.
- * When using "gcc -traditional", we assume that this is the intent; if
- * __GNUC__ is defined but __STDC__ is not, we leave the new keywords alone.
- */
-#ifndef	NO_ANSI_KEYWORDS
-#define	const				/* delete ANSI C keywords */
-#define	inline
-#define	signed
-#define	volatile
-#endif	/* !NO_ANSI_KEYWORDS */
-#endif	/* !__CC_SUPPORTS___INLINE */
-#endif	/* !(__STDC__ || __cplusplus) */
-
-/*
- * Compiler-dependent macros to help declare dead (non-returning) and
- * pure (no side effects) functions, and unused variables.  They are
- * null except for versions of gcc that are known to support the features
- * properly (old versions of gcc-2 supported the dead and pure features
- * in a different (wrong) way).  If we do not provide an implementation
- * for a given compiler, let the compile fail if it is told to use
- * a feature that we cannot live without.
- */
-#define	__weak_symbol	__attribute__((__weak__))
-#if !__GNUC_PREREQ__(2, 5) && !defined(__INTEL_COMPILER)
-#define	__dead2
-#define	__pure2
-#define	__unused
-#endif
-#if __GNUC__ == 2 && __GNUC_MINOR__ >= 5 && __GNUC_MINOR__ < 7 && !defined(__INTEL_COMPILER)
-#define	__dead2		__attribute__((__noreturn__))
-#define	__pure2		__attribute__((__const__))
-#define	__unused
-/* XXX Find out what to do for __packed, __aligned and __section */
-#endif
-#if __GNUC_PREREQ__(2, 7) || defined(__INTEL_COMPILER)
-#define	__dead2		__attribute__((__noreturn__))
-#define	__pure2		__attribute__((__const__))
-#define	__unused	__attribute__((__unused__))
-#define	__used		__attribute__((__used__))
-#define	__packed	__attribute__((__packed__))
-#define	__aligned(x)	__attribute__((__aligned__(x)))
-#define	__section(x)	__attribute__((__section__(x)))
-#endif
-#if __GNUC_PREREQ__(4, 3) || __has_attribute(__alloc_size__)
-#define	__alloc_size(x)	__attribute__((__alloc_size__(x)))
-#define	__alloc_size2(n, x)	__attribute__((__alloc_size__(n, x)))
-#else
-#define	__alloc_size(x)
-#define	__alloc_size2(n, x)
-#endif
-#if __GNUC_PREREQ__(4, 9) || __has_attribute(__alloc_align__)
-#define	__alloc_align(x)	__attribute__((__alloc_align__(x)))
-#else
-#define	__alloc_align(x)
-#endif
-
-#if !__GNUC_PREREQ__(2, 95)
-#define	__alignof(x)	__offsetof(struct { char __a; x __b; }, __b)
-#endif
-
-/*
- * Keywords added in C11.
- */
-
-#if !defined(__STDC_VERSION__) || __STDC_VERSION__ < 201112L
-
-#if !__has_extension(c_alignas)
-#if (defined(__cplusplus) && __cplusplus >= 201103L) || \
-    __has_extension(cxx_alignas)
-#define	_Alignas(x)		alignas(x)
-#else
-/* XXX: Only emulates _Alignas(constant-expression); not _Alignas(type-name). */
-#define	_Alignas(x)		__aligned(x)
-#endif
-#endif
-
-#if defined(__cplusplus) && __cplusplus >= 201103L
-#define	_Alignof(x)		alignof(x)
-#else
-#define	_Alignof(x)		__alignof(x)
-#endif
-
-#if !defined(__cplusplus) && !__has_extension(c_atomic) && \
-    !__has_extension(cxx_atomic)
-/*
- * No native support for _Atomic(). Place object in structure to prevent
- * most forms of direct non-atomic access.
- */
-#define	_Atomic(T)		struct { T volatile __val; }
-#endif
-
-#if defined(__cplusplus) && __cplusplus >= 201103L
-#define	_Noreturn		[[noreturn]]
-#else
-#define	_Noreturn		__dead2
-#endif
-
-#if !__has_extension(c_static_assert)
-#if (defined(__cplusplus) && __cplusplus >= 201103L) || \
-    __has_extension(cxx_static_assert)
-#define	_Static_assert(x, y)	static_assert(x, y)
-#elif __GNUC_PREREQ__(4,6) && !defined(__cplusplus)
-/* Nothing, gcc 4.6 and higher has _Static_assert built-in */
-#elif defined(__COUNTER__)
-#define	_Static_assert(x, y)	__Static_assert(x, __COUNTER__)
-#define	__Static_assert(x, y)	___Static_assert(x, y)
-#define	___Static_assert(x, y)	typedef char __assert_ ## y[(x) ? 1 : -1] \
-				__unused
-#else
-#define	_Static_assert(x, y)	struct __hack
-#endif
-#endif
-
-#if !__has_extension(c_thread_local)
-/*
- * XXX: Some compilers (Clang 3.3, GCC 4.7) falsely announce C++11 mode
- * without actually supporting the thread_local keyword. Don't check for
- * the presence of C++11 when defining _Thread_local.
- */
-#if /* (defined(__cplusplus) && __cplusplus >= 201103L) || */ \
-    __has_extension(cxx_thread_local)
-#define	_Thread_local		thread_local
-#else
-#define	_Thread_local		__thread
-#endif
-#endif
-
-#endif /* __STDC_VERSION__ || __STDC_VERSION__ < 201112L */
-
-/*
- * Emulation of C11 _Generic().  Unlike the previously defined C11
- * keywords, it is not possible to implement this using exactly the same
- * syntax.  Therefore implement something similar under the name
- * __generic().  Unlike _Generic(), this macro can only distinguish
- * between a single type, so it requires nested invocations to
- * distinguish multiple cases.
- */
-
-#if (defined(__STDC_VERSION__) && __STDC_VERSION__ >= 201112L) || \
-    __has_extension(c_generic_selections)
-#define	__generic(expr, t, yes, no)					\
-	_Generic(expr, t: yes, default: no)
-#elif __GNUC_PREREQ__(3, 1) && !defined(__cplusplus)
-#define	__generic(expr, t, yes, no)					\
-	__builtin_choose_expr(						\
-	    __builtin_types_compatible_p(__typeof(expr), t), yes, no)
-#endif
-
-/*
- * C99 Static array indices in function parameter declarations.  Syntax such as:
- * void bar(int myArray[static 10]);
- * is allowed in C99 but not in C++.  Define __min_size appropriately so
- * headers using it can be compiled in either language.  Use like this:
- * void bar(int myArray[__min_size(10)]);
- */
-#if !defined(__cplusplus) && \
-    (defined(__clang__) || __GNUC_PREREQ__(4, 6)) && \
-    (!defined(__STDC_VERSION__) || (__STDC_VERSION__ >= 199901))
-#define __min_size(x)	static (x)
-#else
-#define __min_size(x)	(x)
-#endif
-
-#if __GNUC_PREREQ__(2, 96)
-#define	__malloc_like	__attribute__((__malloc__))
-#define	__pure		__attribute__((__pure__))
-#else
-#define	__malloc_like
-#define	__pure
-#endif
-
-#if __GNUC_PREREQ__(3, 1) || (defined(__INTEL_COMPILER) && __INTEL_COMPILER >= 800)
-#define	__always_inline	__inline__ __attribute__((__always_inline__))
-#else
-#define	__always_inline
-#endif
-
-#if __GNUC_PREREQ__(3, 1)
-#define	__noinline	__attribute__ ((__noinline__))
-#else
-#define	__noinline
-#endif
-
-#if __GNUC_PREREQ__(3, 3)
-#define	__nonnull(x)	__attribute__((__nonnull__ x))
-#define	__nonnull_all	__attribute__((__nonnull__))
-#else
-#define	__nonnull(x)
-#define	__nonnull_all
-#endif
-
-#if __GNUC_PREREQ__(3, 4)
-#define	__fastcall	__attribute__((__fastcall__))
-#define	__result_use_check	__attribute__((__warn_unused_result__))
-#else
-#define	__fastcall
-#define	__result_use_check
-#endif
-
-#if __GNUC_PREREQ__(4, 1)
-#define	__returns_twice	__attribute__((__returns_twice__))
-#else
-#define	__returns_twice
-#endif
-
-#if __GNUC_PREREQ__(4, 6) || __has_builtin(__builtin_unreachable)
-#define	__unreachable()	__builtin_unreachable()
-#else
-#define	__unreachable()	((void)0)
-#endif
-
-/* XXX: should use `#if __STDC_VERSION__ < 199901'. */
-#if !__GNUC_PREREQ__(2, 7) && !defined(__INTEL_COMPILER)
-#define	__func__	NULL
-#endif
-
-/*
- * GCC 2.95 provides `__restrict' as an extension to C90 to support the
- * C99-specific `restrict' type qualifier.  We happen to use `__restrict' as
- * a way to define the `restrict' type qualifier without disturbing older
- * software that is unaware of C99 keywords.
- */
-#if !(__GNUC__ == 2 && __GNUC_MINOR__ == 95)
-#if !defined(__STDC_VERSION__) || __STDC_VERSION__ < 199901
-#define	__restrict
-#else
-#define	__restrict	restrict
-#endif
-#endif
-
-/*
- * GNU C version 2.96 adds explicit branch prediction so that
- * the CPU back-end can hint the processor and also so that
- * code blocks can be reordered such that the predicted path
- * sees a more linear flow, thus improving cache behavior, etc.
- *
- * The following two macros provide us with a way to utilize this
- * compiler feature.  Use __predict_true() if you expect the expression
- * to evaluate to true, and __predict_false() if you expect the
- * expression to evaluate to false.
- *
- * A few notes about usage:
- *
- *	* Generally, __predict_false() error condition checks (unless
- *	  you have some _strong_ reason to do otherwise, in which case
- *	  document it), and/or __predict_true() `no-error' condition
- *	  checks, assuming you want to optimize for the no-error case.
- *
- *	* Other than that, if you don't know the likelihood of a test
- *	  succeeding from empirical or other `hard' evidence, don't
- *	  make predictions.
- *
- *	* These are meant to be used in places that are run `a lot'.
- *	  It is wasteful to make predictions in code that is run
- *	  seldomly (e.g. at subsystem initialization time) as the
- *	  basic block reordering that this affects can often generate
- *	  larger code.
- */
-#if __GNUC_PREREQ__(2, 96)
-#define	__predict_true(exp)     __builtin_expect((exp), 1)
-#define	__predict_false(exp)    __builtin_expect((exp), 0)
-#else
-#define	__predict_true(exp)     (exp)
-#define	__predict_false(exp)    (exp)
-#endif
-
-#if __GNUC_PREREQ__(4, 0)
-#define	__null_sentinel	__attribute__((__sentinel__))
-#define	__exported	__attribute__((__visibility__("default")))
-/* Only default visibility is supported on PE/COFF targets. */
-#ifndef __CYGWIN__
-#define	__hidden	__attribute__((__visibility__("hidden")))
-#else
-#define	__hidden
-#endif
-#else
-#define	__null_sentinel
-#define	__exported
-#define	__hidden
-#endif
-
-#define __offsetof(type, field)	offsetof(type, field)
-#define	__rangeof(type, start, end) \
-	(__offsetof(type, end) - __offsetof(type, start))
-
-/*
- * Given the pointer x to the member m of the struct s, return
- * a pointer to the containing structure.  When using GCC, we first
- * assign pointer x to a local variable, to check that its type is
- * compatible with member m.
- */
-#if __GNUC_PREREQ__(3, 1)
-#define	__containerof(x, s, m) ({					\
-	const volatile __typeof(((s *)0)->m) *__x = (x);		\
-	__DEQUALIFY(s *, (const volatile char *)__x - __offsetof(s, m));\
-})
-#else
-#define	__containerof(x, s, m)						\
-	__DEQUALIFY(s *, (const volatile char *)(x) - __offsetof(s, m))
-#endif
-
-/*
- * Compiler-dependent macros to declare that functions take printf-like
- * or scanf-like arguments.  They are null except for versions of gcc
- * that are known to support the features properly (old versions of gcc-2
- * didn't permit keeping the keywords out of the application namespace).
- */
-#if !__GNUC_PREREQ__(2, 7) && !defined(__INTEL_COMPILER)
-#define	__printflike(fmtarg, firstvararg)
-#define	__scanflike(fmtarg, firstvararg)
-#define	__format_arg(fmtarg)
-#define	__strfmonlike(fmtarg, firstvararg)
-#define	__strftimelike(fmtarg, firstvararg)
-#else
-#define	__printflike(fmtarg, firstvararg) \
-	    __attribute__((__format__ (__printf__, fmtarg, firstvararg)))
-#define	__scanflike(fmtarg, firstvararg) \
-	    __attribute__((__format__ (__scanf__, fmtarg, firstvararg)))
-#define	__format_arg(fmtarg)	__attribute__((__format_arg__ (fmtarg)))
-#define	__strfmonlike(fmtarg, firstvararg) \
-	    __attribute__((__format__ (__strfmon__, fmtarg, firstvararg)))
-#define	__strftimelike(fmtarg, firstvararg) \
-	    __attribute__((__format__ (__strftime__, fmtarg, firstvararg)))
-#endif
-
-/* Compiler-dependent macros that rely on FreeBSD-specific extensions. */
-#if defined(__FreeBSD_cc_version) && __FreeBSD_cc_version >= 300001 && \
-    defined(__GNUC__) && !defined(__INTEL_COMPILER)
-#define	__printf0like(fmtarg, firstvararg) \
-	    __attribute__((__format__ (__printf0__, fmtarg, firstvararg)))
-#else
-#define	__printf0like(fmtarg, firstvararg)
-#endif
-
-#if defined(__GNUC__) || defined(__INTEL_COMPILER)
-#ifndef __INTEL_COMPILER
-#define	__strong_reference(sym,aliassym)	\
-	extern __typeof (sym) aliassym __attribute__ ((__alias__ (#sym)))
-#endif
-#ifdef __ELF__
-#ifdef __STDC__
-#define	__weak_reference(sym,alias)	\
-	__asm__(".weak " #alias);	\
-	__asm__(".equ "  #alias ", " #sym)
-#define	__warn_references(sym,msg)	\
-	__asm__(".section .gnu.warning." #sym);	\
-	__asm__(".asciz \"" msg "\"");	\
-	__asm__(".previous")
-#define	__sym_compat(sym,impl,verid)	\
-	__asm__(".symver " #impl ", " #sym "@" #verid)
-#define	__sym_default(sym,impl,verid)	\
-	__asm__(".symver " #impl ", " #sym "@@" #verid)
-#else
-#define	__weak_reference(sym,alias)	\
-	__asm__(".weak alias");		\
-	__asm__(".equ alias, sym")
-#define	__warn_references(sym,msg)	\
-	__asm__(".section .gnu.warning.sym"); \
-	__asm__(".asciz \"msg\"");	\
-	__asm__(".previous")
-#define	__sym_compat(sym,impl,verid)	\
-	__asm__(".symver impl, sym@verid")
-#define	__sym_default(impl,sym,verid)	\
-	__asm__(".symver impl, sym@@verid")
-#endif	/* __STDC__ */
-#else	/* !__ELF__ */
-#ifdef __STDC__
-#define	__weak_reference(sym,alias)	\
-	__asm__(".stabs \"_" #alias "\",11,0,0,0");	\
-	__asm__(".stabs \"_" #sym "\",1,0,0,0")
-#define	__warn_references(sym,msg)	\
-	__asm__(".stabs \"" msg "\",30,0,0,0");		\
-	__asm__(".stabs \"_" #sym "\",1,0,0,0")
-#else
-#define	__weak_reference(sym,alias)	\
-	__asm__(".stabs \"_/**/alias\",11,0,0,0");	\
-	__asm__(".stabs \"_/**/sym\",1,0,0,0")
-#define	__warn_references(sym,msg)	\
-	__asm__(".stabs msg,30,0,0,0");			\
-	__asm__(".stabs \"_/**/sym\",1,0,0,0")
-#endif	/* __STDC__ */
-#endif	/* __ELF__ */
-#endif	/* __GNUC__ || __INTEL_COMPILER */
-
-#ifndef	__FBSDID
-#define	__FBSDID(s)	struct __hack
-#endif
-
-#ifndef	__RCSID
-#define	__RCSID(s)	struct __hack
-#endif
-
-#ifndef	__RCSID_SOURCE
-#define	__RCSID_SOURCE(s)	struct __hack
-#endif
-
-#ifndef	__SCCSID
-#define	__SCCSID(s)	struct __hack
-#endif
-
-#ifndef	__COPYRIGHT
-#define	__COPYRIGHT(s)	struct __hack
-#endif
-
-#ifndef	__DECONST
-#define	__DECONST(type, var)	((type)(__uintptr_t)(const void *)(var))
-#endif
-
-#ifndef	__DEVOLATILE
-#define	__DEVOLATILE(type, var)	((type)(__uintptr_t)(volatile void *)(var))
-#endif
-
-#ifndef	__DEQUALIFY
-#define	__DEQUALIFY(type, var)	((type)(__uintptr_t)(const volatile void *)(var))
-#endif
-
-/*
- * Nullability qualifiers: currently only supported by Clang.
- */
-#if !(defined(__clang__) && __has_feature(nullability))
-#define	_Nonnull
-#define	_Nullable
-#define	_Null_unspecified
-#define	__NULLABILITY_PRAGMA_PUSH
-#define	__NULLABILITY_PRAGMA_POP
-#else
-#define	__NULLABILITY_PRAGMA_PUSH _Pragma("clang diagnostic push")	\
-	_Pragma("clang diagnostic ignored \"-Wnullability-completeness\"")
-#define	__NULLABILITY_PRAGMA_POP _Pragma("clang diagnostic pop")
-#endif
-
-/*
- * Type Safety Checking
- *
- * Clang provides additional attributes to enable checking type safety
- * properties that cannot be enforced by the C type system. 
- */
-
-#if __has_attribute(__argument_with_type_tag__) && \
-    __has_attribute(__type_tag_for_datatype__)
-#define	__arg_type_tag(arg_kind, arg_idx, type_tag_idx) \
-	    __attribute__((__argument_with_type_tag__(arg_kind, arg_idx, type_tag_idx)))
-#define	__datatype_type_tag(kind, type) \
-	    __attribute__((__type_tag_for_datatype__(kind, type)))
-#else
-#define	__arg_type_tag(arg_kind, arg_idx, type_tag_idx)
-#define	__datatype_type_tag(kind, type)
-#endif
-
-/*
- * Lock annotations.
- *
- * Clang provides support for doing basic thread-safety tests at
- * compile-time, by marking which locks will/should be held when
- * entering/leaving a functions.
- *
- * Furthermore, it is also possible to annotate variables and structure
- * members to enforce that they are only accessed when certain locks are
- * held.
- */
-
-#if __has_extension(c_thread_safety_attributes)
-#define	__lock_annotate(x)	__attribute__((x))
-#else
-#define	__lock_annotate(x)
-#endif
-
-/* Structure implements a lock. */
-/* FIXME: Use __lockable__, etc. to avoid colliding with user namespace macros,
- * once clang is fixed: https://bugs.llvm.org/show_bug.cgi?id=34319 */
-#define	__lockable		__lock_annotate(lockable)
-
-/* Function acquires an exclusive or shared lock. */
-#define	__locks_exclusive(...) \
-	__lock_annotate(exclusive_lock_function(__VA_ARGS__))
-#define	__locks_shared(...) \
-	__lock_annotate(shared_lock_function(__VA_ARGS__))
-
-/* Function attempts to acquire an exclusive or shared lock. */
-#define	__trylocks_exclusive(...) \
-	__lock_annotate(exclusive_trylock_function(__VA_ARGS__))
-#define	__trylocks_shared(...) \
-	__lock_annotate(shared_trylock_function(__VA_ARGS__))
-
-/* Function releases a lock. */
-#define	__unlocks(...)		__lock_annotate(unlock_function(__VA_ARGS__))
-
-/* Function asserts that an exclusive or shared lock is held. */
-#define	__asserts_exclusive(...) \
-	__lock_annotate(assert_exclusive_lock(__VA_ARGS__))
-#define	__asserts_shared(...) \
-	__lock_annotate(assert_shared_lock(__VA_ARGS__))
-
-/* Function requires that an exclusive or shared lock is or is not held. */
-#define	__requires_exclusive(...) \
-	__lock_annotate(exclusive_locks_required(__VA_ARGS__))
-#define	__requires_shared(...) \
-	__lock_annotate(shared_locks_required(__VA_ARGS__))
-#define	__requires_unlocked(...) \
-	__lock_annotate(locks_excluded(__VA_ARGS__))
-
-/* Function should not be analyzed. */
-#define	__no_lock_analysis	__lock_annotate(no_thread_safety_analysis)
-
-/* Guard variables and structure members by lock. */
-#define	__guarded_by(x)		__lock_annotate(guarded_by(x))
-#define	__pt_guarded_by(x)	__lock_annotate(pt_guarded_by(x))
-
-#endif /* !_SYS_CDEFS_H_ */

src/include/sys/config.h

@@ -1,300 +0,0 @@
-#ifndef __SYS_CONFIG_H__
-#define __SYS_CONFIG_H__
-
-#include <machine/ieeefp.h>  /* floating point macros */
-#include <sys/features.h>	/* POSIX defs */
-
-#ifdef __aarch64__
-#define MALLOC_ALIGNMENT 16
-#endif
-
-/* exceptions first */
-#if defined(__H8500__) || defined(__W65__)
-#define __SMALL_BITFIELDS
-/* ???  This conditional is true for the h8500 and the w65, defining H8300
-   in those cases probably isn't the right thing to do.  */
-#define H8300 1
-#endif
-
-/* 16 bit integer machines */
-#if defined(__Z8001__) || defined(__Z8002__) || defined(__H8500__) || defined(__W65__) || defined (__mn10200__) || defined (__AVR__)
-
-#undef INT_MAX
-#undef UINT_MAX
-#define INT_MAX 32767
-#define UINT_MAX 65535
-#endif
-
-#if defined (__H8300__) || defined (__H8300H__) || defined(__H8300S__) || defined (__H8300SX__)
-#define __SMALL_BITFIELDS
-#define H8300 1
-#undef INT_MAX
-#undef UINT_MAX
-#define INT_MAX __INT_MAX__
-#define UINT_MAX (__INT_MAX__ * 2U + 1)
-#endif
-
-#if (defined(__CR16__) || defined(__CR16C__) ||defined(__CR16CP__))
-#ifndef __INT32__
-#define __SMALL_BITFIELDS      
-#undef INT_MAX
-#undef UINT_MAX
-#define INT_MAX 32767
-#define UINT_MAX (__INT_MAX__ * 2U + 1)
-#else /* INT32 */
-#undef INT_MAX
-#undef UINT_MAX
-#define INT_MAX 2147483647
-#define UINT_MAX (__INT_MAX__ * 2U + 1)
-#endif /* INT32 */
-
-#endif /* CR16C */
-
-#if defined (__xc16x__) || defined (__xc16xL__) || defined (__xc16xS__)
-#define __SMALL_BITFIELDS
-#endif
-
-#ifdef __W65__
-#define __SMALL_BITFIELDS
-#endif
-
-#if defined(__D10V__)
-#define __SMALL_BITFIELDS
-#undef INT_MAX
-#undef UINT_MAX
-#define INT_MAX __INT_MAX__
-#define UINT_MAX (__INT_MAX__ * 2U + 1)
-#define _POINTER_INT short
-#endif
-
-#if defined(__mc68hc11__) || defined(__mc68hc12__) || defined(__mc68hc1x__)
-#undef INT_MAX
-#undef UINT_MAX
-#define INT_MAX __INT_MAX__
-#define UINT_MAX (__INT_MAX__ * 2U + 1)
-#define _POINTER_INT short
-#endif
-
-#if defined(__m68k__) || defined(__mc68000__) || defined(__riscv)
-#define _READ_WRITE_RETURN_TYPE _ssize_t
-#endif
-
-#ifdef ___AM29K__
-#define _FLOAT_RET double
-#endif
-
-#ifdef __i386__
-#ifndef __unix__
-/* in other words, go32 */
-#define _FLOAT_RET double
-#endif
-#if defined(__linux__) || defined(__RDOS__)
-/* we want the reentrancy structure to be returned by a function */
-#define __DYNAMIC_REENT__
-#define HAVE_GETDATE
-#define _READ_WRITE_RETURN_TYPE _ssize_t
-#define __LARGE64_FILES 1
-/* we use some glibc header files so turn on glibc large file feature */
-#define _LARGEFILE64_SOURCE 1
-#endif
-#endif
-
-#ifdef __mn10200__
-#define __SMALL_BITFIELDS
-#endif
-
-#ifdef __AVR__
-#define __SMALL_BITFIELDS
-#define _POINTER_INT short
-#endif
-
-#if defined(__v850) && !defined(__rtems__)
-#define __ATTRIBUTE_IMPURE_PTR__ __attribute__((__sda__))
-#endif
-
-/* For the PowerPC eabi, force the _impure_ptr to be in .sdata */
-#if defined(__PPC__)
-#if defined(_CALL_SYSV)
-#define __ATTRIBUTE_IMPURE_PTR__ __attribute__((__section__(".sdata")))
-#endif
-#ifdef __SPE__
-#define _LONG_DOUBLE double
-#endif
-#endif
-
-/* Configure small REENT structure for Xilinx MicroBlaze platforms */
-#if defined (__MICROBLAZE__)
-#ifndef _REENT_SMALL
-#define _REENT_SMALL
-#endif
-/* Xilinx XMK uses Unix98 mutex */
-#ifdef __XMK__
-#define _UNIX98_THREAD_MUTEX_ATTRIBUTES
-#endif
-#endif
-
-#if defined(__mips__) && !defined(__rtems__)
-#define __ATTRIBUTE_IMPURE_PTR__ __attribute__((__section__(".sdata")))
-#endif
-
-#ifdef __xstormy16__
-#define __SMALL_BITFIELDS
-#undef INT_MAX
-#undef UINT_MAX
-#define INT_MAX __INT_MAX__
-#define UINT_MAX (__INT_MAX__ * 2U + 1)
-#define MALLOC_ALIGNMENT 8
-#define _POINTER_INT short
-#define __BUFSIZ__ 16
-#define _REENT_SMALL
-#endif
-
-#if defined __MSP430__
-#ifndef _REENT_SMALL
-#define _REENT_SMALL
-#endif
-
-#define __BUFSIZ__ 256
-#define __SMALL_BITFIELDS
-
-#ifdef __MSP430X_LARGE__
-#define _POINTER_INT long
-#else
-#define _POINTER_INT int
-#endif
-#endif
-
-#ifdef __m32c__
-#define __SMALL_BITFIELDS
-#undef INT_MAX
-#undef UINT_MAX
-#define INT_MAX __INT_MAX__
-#define UINT_MAX (__INT_MAX__ * 2U + 1)
-#define MALLOC_ALIGNMENT 8
-#if defined(__r8c_cpu__) || defined(__m16c_cpu__)
-#define _POINTER_INT short
-#else
-#define _POINTER_INT long
-#endif
-#define __BUFSIZ__ 16
-#define _REENT_SMALL
-#endif /* __m32c__ */
-
-#ifdef __SPU__
-#define MALLOC_ALIGNMENT 16
-#define __CUSTOM_FILE_IO__
-#endif
-
-#if defined(__or1k__) || defined(__or1knd__)
-#define __DYNAMIC_REENT__
-#endif
-
-/* This block should be kept in sync with GCC's limits.h.  The point
-   of having these definitions here is to not include limits.h, which
-   would pollute the user namespace, while still using types of the
-   the correct widths when deciding how to define __int32_t and
-   __int64_t.  */
-#ifndef __INT_MAX__
-# ifdef INT_MAX
-#  define __INT_MAX__ INT_MAX
-# else
-#  define __INT_MAX__ 2147483647
-# endif
-#endif
-
-#ifndef __LONG_MAX__
-# ifdef LONG_MAX
-#  define __LONG_MAX__ LONG_MAX
-# else
-#  if defined (__alpha__) || (defined (__sparc__) && defined(__arch64__)) \
-      || defined (__sparcv9)
-#   define __LONG_MAX__ 9223372036854775807L
-#  else
-#   define __LONG_MAX__ 2147483647L
-#  endif /* __alpha__ || sparc64 */
-# endif
-#endif
-/* End of block that should be kept in sync with GCC's limits.h.  */
-
-#ifndef _POINTER_INT
-#define _POINTER_INT long
-#endif
-
-#ifdef __frv__
-#define __ATTRIBUTE_IMPURE_PTR__ __attribute__((__section__(".sdata")))
-#endif
-#undef __RAND_MAX
-#if __INT_MAX__ == 32767
-#define __RAND_MAX 32767
-#else
-#define __RAND_MAX 0x7fffffff
-#endif
-
-#if defined(__CYGWIN__)
-#include <cygwin/config.h>
-#endif
-
-#if defined(__rtems__)
-#define __FILENAME_MAX__ 255
-#define _READ_WRITE_RETURN_TYPE _ssize_t
-#define __DYNAMIC_REENT__
-#define _REENT_GLOBAL_ATEXIT
-#define _REENT_GLOBAL_STDIO_STREAMS
-#endif
-
-#ifndef __EXPORT
-#define __EXPORT
-#endif
-
-#ifndef __IMPORT
-#define __IMPORT
-#endif
-
-/* Define return type of read/write routines.  In POSIX, the return type
-   for read()/write() is "ssize_t" but legacy newlib code has been using
-   "int" for some time.  If not specified, "int" is defaulted.  */
-#ifndef _READ_WRITE_RETURN_TYPE
-#define _READ_WRITE_RETURN_TYPE int
-#endif
-/* Define `count' parameter of read/write routines.  In POSIX, the `count'
-   parameter is "size_t" but legacy newlib code has been using "int" for some
-   time.  If not specified, "int" is defaulted.  */
-#ifndef _READ_WRITE_BUFSIZE_TYPE
-#define _READ_WRITE_BUFSIZE_TYPE int
-#endif
-
-#ifndef __WCHAR_MAX__
-#if __INT_MAX__ == 32767 || defined (_WIN32)
-#define __WCHAR_MAX__ 0xffffu
-#endif
-#endif
-
-/* See if small reent asked for at configuration time and
-   is not chosen by the platform by default.  */
-#ifdef _WANT_REENT_SMALL
-#ifndef _REENT_SMALL
-#define _REENT_SMALL
-#endif
-#endif
-
-#ifdef _WANT_REENT_GLOBAL_STDIO_STREAMS
-#ifndef _REENT_GLOBAL_STDIO_STREAMS
-#define _REENT_GLOBAL_STDIO_STREAMS
-#endif
-#endif
-
-#ifdef _WANT_USE_LONG_TIME_T
-#ifndef _USE_LONG_TIME_T
-#define _USE_LONG_TIME_T
-#endif
-#endif
-
-/* If _MB_EXTENDED_CHARSETS_ALL is set, we want all of the extended
-   charsets.  The extended charsets add a few functions and a couple
-   of tables of a few K each. */
-#ifdef _MB_EXTENDED_CHARSETS_ALL
-#define _MB_EXTENDED_CHARSETS_ISO 1
-#define _MB_EXTENDED_CHARSETS_WINDOWS 1
-#endif
-
-#endif /* __SYS_CONFIG_H__ */

src/include/sys/features.h

@@ -1,533 +0,0 @@
-/*
- *  Written by Joel Sherrill <joel@OARcorp.com>.
- *
- *  COPYRIGHT (c) 1989-2014.
- *
- *  On-Line Applications Research Corporation (OAR).
- *
- *  Permission to use, copy, modify, and distribute this software for any
- *  purpose without fee is hereby granted, provided that this entire notice
- *  is included in all copies of any software which is or includes a copy
- *  or modification of this software.
- *
- *  THIS SOFTWARE IS BEING PROVIDED "AS IS", WITHOUT ANY EXPRESS OR IMPLIED
- *  WARRANTY.  IN PARTICULAR,  THE AUTHOR MAKES NO REPRESENTATION
- *  OR WARRANTY OF ANY KIND CONCERNING THE MERCHANTABILITY OF THIS
- *  SOFTWARE OR ITS FITNESS FOR ANY PARTICULAR PURPOSE.
- *
- *  $Id$
- */
-
-#ifndef _SYS_FEATURES_H
-#define _SYS_FEATURES_H
-
-#ifdef __cplusplus
-extern "C" {
-#endif
-
-#include <_newlib_version.h>
-
-/* Macro to test version of GCC.  Returns 0 for non-GCC or too old GCC. */
-#ifndef __GNUC_PREREQ
-# if defined __GNUC__ && defined __GNUC_MINOR__
-#  define __GNUC_PREREQ(maj, min) \
-	((__GNUC__ << 16) + __GNUC_MINOR__ >= ((maj) << 16) + (min))
-# else
-#  define __GNUC_PREREQ(maj, min) 0
-# endif
-#endif /* __GNUC_PREREQ */
-/* Version with trailing underscores for BSD compatibility. */
-#define	__GNUC_PREREQ__(ma, mi)	__GNUC_PREREQ(ma, mi)
-
-
-/*
- * Feature test macros control which symbols are exposed by the system
- * headers.  Any of these must be defined before including any headers.
- *
- * __STRICT_ANSI__ (defined by gcc -ansi, -std=c90, -std=c99, or -std=c11)
- *	ISO C
- *
- * _POSIX_SOURCE (deprecated by _POSIX_C_SOURCE=1)
- * _POSIX_C_SOURCE >= 1
- * 	POSIX.1-1990
- *
- * _POSIX_C_SOURCE >= 2
- * 	POSIX.2-1992
- *
- * _POSIX_C_SOURCE >= 199309L
- * 	POSIX.1b-1993 Real-time extensions
- *
- * _POSIX_C_SOURCE >= 199506L
- * 	POSIX.1c-1995 Threads extensions
- *
- * _POSIX_C_SOURCE >= 200112L
- * 	POSIX.1-2001 and C99
- *
- * _POSIX_C_SOURCE >= 200809L
- * 	POSIX.1-2008
- *
- * _XOPEN_SOURCE
- *	POSIX.1-1990 and XPG4
- *
- * _XOPEN_SOURCE_EXTENDED
- *	SUSv1 (POSIX.2-1992 plus XPG4v2)
- *
- * _XOPEN_SOURCE >= 500
- *	SUSv2 (POSIX.1c-1995 plus XSI)
- *
- * _XOPEN_SOURCE >= 600
- *	SUSv3 (POSIX.1-2001 plus XSI) and C99
- *
- * _XOPEN_SOURCE >= 700
- *	SUSv4 (POSIX.1-2008 plus XSI)
- *
- * _ISOC99_SOURCE or gcc -std=c99 or g++
- * 	ISO C99
- *
- * _ISOC11_SOURCE or gcc -std=c11 or g++ -std=c++11
- * 	ISO C11
- *
- * _ATFILE_SOURCE (implied by _POSIX_C_SOURCE >= 200809L)
- *	"at" functions
- *
- * _LARGEFILE_SOURCE (deprecated by _XOPEN_SOURCE >= 500)
- *	fseeko, ftello
- *
- * _GNU_SOURCE
- * 	All of the above plus GNU extensions
- *
- * _BSD_SOURCE (deprecated by _DEFAULT_SOURCE)
- * _SVID_SOURCE (deprecated by _DEFAULT_SOURCE)
- * _DEFAULT_SOURCE (or none of the above)
- * 	POSIX-1.2008 with BSD and SVr4 extensions
- *
- * _FORTIFY_SOURCE = 1 or 2
- * 	Object Size Checking function wrappers
- */
-
-#ifdef _GNU_SOURCE
-#undef _ATFILE_SOURCE
-#define	_ATFILE_SOURCE		1
-#undef	_DEFAULT_SOURCE
-#define	_DEFAULT_SOURCE		1
-#undef _ISOC99_SOURCE
-#define	_ISOC99_SOURCE		1
-#undef _ISOC11_SOURCE
-#define	_ISOC11_SOURCE		1
-#undef _POSIX_SOURCE
-#define	_POSIX_SOURCE		1
-#undef _POSIX_C_SOURCE
-#define	_POSIX_C_SOURCE		200809L
-#undef _XOPEN_SOURCE
-#define	_XOPEN_SOURCE		700
-#undef _XOPEN_SOURCE_EXTENDED
-#define	_XOPEN_SOURCE_EXTENDED	1
-#endif /* _GNU_SOURCE */
-
-#if defined(_BSD_SOURCE) || defined(_SVID_SOURCE) || \
-   (!defined(__STRICT_ANSI__) && !defined(_ANSI_SOURCE) && \
-   !defined(_ISOC99_SOURCE) && !defined(_POSIX_SOURCE) && \
-   !defined(_POSIX_C_SOURCE) && !defined(_XOPEN_SOURCE))
-#undef _DEFAULT_SOURCE
-#define	_DEFAULT_SOURCE		1
-#endif
-
-#if defined(_DEFAULT_SOURCE)
-#undef _POSIX_SOURCE
-#define	_POSIX_SOURCE		1
-#undef _POSIX_C_SOURCE
-#define	_POSIX_C_SOURCE		200809L
-#endif
-
-#if !defined(_POSIX_SOURCE) && !defined(_POSIX_C_SOURCE) && \
-  ((!defined(__STRICT_ANSI__) && !defined(_ANSI_SOURCE)) || \
-   (_XOPEN_SOURCE - 0) >= 500)
-#define	_POSIX_SOURCE		1
-#if !defined(_XOPEN_SOURCE) || (_XOPEN_SOURCE - 0) >= 700
-#define	_POSIX_C_SOURCE		200809L
-#elif (_XOPEN_SOURCE - 0) >= 600
-#define	_POSIX_C_SOURCE		200112L
-#elif (_XOPEN_SOURCE - 0) >= 500
-#define	_POSIX_C_SOURCE		199506L
-#elif (_XOPEN_SOURCE - 0) < 500
-#define	_POSIX_C_SOURCE		2
-#endif
-#endif
-
-#if defined(_POSIX_C_SOURCE) && _POSIX_C_SOURCE >= 200809
-#undef _ATFILE_SOURCE
-#define	_ATFILE_SOURCE		1
-#endif
-
-/*
- * The following private macros are used throughout the headers to control
- * which symbols should be exposed.  They are for internal use only, as
- * indicated by the leading double underscore, and must never be used outside
- * of these headers.
- *
- * __POSIX_VISIBLE
- * 	any version of POSIX.1; enabled by default, or with _POSIX_SOURCE,
- * 	any value of _POSIX_C_SOURCE, or _XOPEN_SOURCE >= 500.
- *
- * __POSIX_VISIBLE >= 2
- * 	POSIX.2-1992; enabled by default, with _POSIX_C_SOURCE >= 2,
- * 	or _XOPEN_SOURCE >= 500.
- *
- * __POSIX_VISIBLE >= 199309
- * 	POSIX.1b-1993; enabled by default, with _POSIX_C_SOURCE >= 199309L,
- * 	or _XOPEN_SOURCE >= 500.
- *
- * __POSIX_VISIBLE >= 199506
- * 	POSIX.1c-1995; enabled by default, with _POSIX_C_SOURCE >= 199506L,
- * 	or _XOPEN_SOURCE >= 500.
- *
- * __POSIX_VISIBLE >= 200112
- * 	POSIX.1-2001; enabled by default, with _POSIX_C_SOURCE >= 200112L,
- * 	or _XOPEN_SOURCE >= 600.
- *
- * __POSIX_VISIBLE >= 200809
- * 	POSIX.1-2008; enabled by default, with _POSIX_C_SOURCE >= 200809L,
- * 	or _XOPEN_SOURCE >= 700.
- *
- * __XSI_VISIBLE
- *	XPG4 XSI extensions; enabled with any version of _XOPEN_SOURCE.
- *
- * __XSI_VISIBLE >= 4
- *	SUSv1 XSI extensions; enabled with both _XOPEN_SOURCE and
- * 	_XOPEN_SOURCE_EXTENDED together.
- *
- * __XSI_VISIBLE >= 500
- *	SUSv2 XSI extensions; enabled with _XOPEN_SOURCE >= 500.
- *
- * __XSI_VISIBLE >= 600
- *	SUSv3 XSI extensions; enabled with _XOPEN_SOURCE >= 600.
- *
- * __XSI_VISIBLE >= 700
- *	SUSv4 XSI extensions; enabled with _XOPEN_SOURCE >= 700.
- *
- * __ISO_C_VISIBLE >= 1999
- * 	ISO C99; enabled with gcc -std=c99 or newer (on by default since GCC 5),
- * 	any version of C++, or with _ISOC99_SOURCE, _POSIX_C_SOURCE >= 200112L,
- * 	or _XOPEN_SOURCE >= 600.
- *
- * __ISO_C_VISIBLE >= 2011
- * 	ISO C11; enabled with gcc -std=c11 or newer (on by default since GCC 5),
- * 	g++ -std=c++11 or newer (on by default since GCC 6), or with
- * 	_ISOC11_SOURCE.
- *
- * __ATFILE_VISIBLE
- *	"at" functions; enabled by default, with _ATFILE_SOURCE,
- * 	_POSIX_C_SOURCE >= 200809L, or _XOPEN_SOURCE >= 700.
- *
- * __LARGEFILE_VISIBLE
- *	fseeko, ftello; enabled with _LARGEFILE_SOURCE or _XOPEN_SOURCE >= 500.
- *
- * __BSD_VISIBLE
- * 	BSD extensions; enabled by default, or with _BSD_SOURCE.
- *
- * __SVID_VISIBLE
- * 	SVr4 extensions; enabled by default, or with _SVID_SOURCE.
- *
- * __MISC_VISIBLE
- * 	Extensions found in both BSD and SVr4 (shorthand for
- * 	(__BSD_VISIBLE || __SVID_VISIBLE)), or newlib-specific
- * 	extensions; enabled by default.
- *
- * __GNU_VISIBLE
- * 	GNU extensions; enabled with _GNU_SOURCE.
- *
- * __SSP_FORTIFY_LEVEL
- * 	Object Size Checking; defined to 0 (off), 1, or 2.
- *
- * In all cases above, "enabled by default" means either by defining
- * _DEFAULT_SOURCE, or by not defining any of the public feature test macros.
- */
-
-#ifdef _ATFILE_SOURCE
-#define	__ATFILE_VISIBLE	1
-#else
-#define	__ATFILE_VISIBLE	0
-#endif
-
-#ifdef _DEFAULT_SOURCE
-#define	__BSD_VISIBLE		1
-#else
-#define	__BSD_VISIBLE		0
-#endif
-
-#ifdef _GNU_SOURCE
-#define	__GNU_VISIBLE		1
-#else
-#define	__GNU_VISIBLE		0
-#endif
-
-#if defined(_ISOC11_SOURCE) || \
-  (__STDC_VERSION__ - 0) >= 201112L || (__cplusplus - 0) >= 201103L
-#define	__ISO_C_VISIBLE		2011
-#elif defined(_ISOC99_SOURCE) || (_POSIX_C_SOURCE - 0) >= 200112L || \
-  (__STDC_VERSION__ - 0) >= 199901L || defined(__cplusplus)
-#define	__ISO_C_VISIBLE		1999
-#else
-#define	__ISO_C_VISIBLE		1990
-#endif
-
-#if defined(_LARGEFILE_SOURCE) || (_XOPEN_SOURCE - 0) >= 500
-#define	__LARGEFILE_VISIBLE	1
-#else
-#define	__LARGEFILE_VISIBLE	0
-#endif
-
-#ifdef _DEFAULT_SOURCE
-#define	__MISC_VISIBLE		1
-#else
-#define	__MISC_VISIBLE		0
-#endif
-
-#if (_POSIX_C_SOURCE - 0) >= 200809L
-#define	__POSIX_VISIBLE		200809
-#elif (_POSIX_C_SOURCE - 0) >= 200112L
-#define	__POSIX_VISIBLE		200112
-#elif (_POSIX_C_SOURCE - 0) >= 199506L
-#define	__POSIX_VISIBLE		199506
-#elif (_POSIX_C_SOURCE - 0) >= 199309L
-#define	__POSIX_VISIBLE		199309
-#elif (_POSIX_C_SOURCE - 0) >= 2 || defined(_XOPEN_SOURCE)
-#define	__POSIX_VISIBLE		199209
-#elif defined(_POSIX_SOURCE) || defined(_POSIX_C_SOURCE)
-#define	__POSIX_VISIBLE		199009
-#else
-#define	__POSIX_VISIBLE		0
-#endif
-
-#ifdef _DEFAULT_SOURCE
-#define	__SVID_VISIBLE		1
-#else
-#define	__SVID_VISIBLE		0
-#endif
-
-#if (_XOPEN_SOURCE - 0) >= 700
-#define	__XSI_VISIBLE		700
-#elif (_XOPEN_SOURCE - 0) >= 600
-#define	__XSI_VISIBLE		600
-#elif (_XOPEN_SOURCE - 0) >= 500
-#define	__XSI_VISIBLE		500
-#elif defined(_XOPEN_SOURCE) && defined(_XOPEN_SOURCE_EXTENDED)
-#define	__XSI_VISIBLE		4
-#elif defined(_XOPEN_SOURCE)
-#define	__XSI_VISIBLE		1
-#else
-#define	__XSI_VISIBLE		0
-#endif
-
-#if _FORTIFY_SOURCE > 0 && !defined(__cplusplus) && !defined(__lint__) && \
-   (__OPTIMIZE__ > 0 || defined(__clang__)) && __GNUC_PREREQ__(4, 1)
-#  if _FORTIFY_SOURCE > 1
-#    define __SSP_FORTIFY_LEVEL 2
-#  else
-#    define __SSP_FORTIFY_LEVEL 1
-#  endif
-#else
-#  define __SSP_FORTIFY_LEVEL 0
-#endif
-
-/* RTEMS adheres to POSIX -- 1003.1b with some features from annexes.  */
-
-#ifdef __rtems__
-#define _POSIX_JOB_CONTROL     		1
-#define _POSIX_SAVED_IDS       		1
-#define _POSIX_VERSION			199309L
-#define _POSIX_ASYNCHRONOUS_IO		1
-#define _POSIX_FSYNC			1
-#define _POSIX_MAPPED_FILES		1
-#define _POSIX_MEMLOCK			1
-#define _POSIX_MEMLOCK_RANGE		1
-#define _POSIX_MEMORY_PROTECTION	1
-#define _POSIX_MESSAGE_PASSING		1
-#define _POSIX_MONOTONIC_CLOCK		200112L
-#define _POSIX_CLOCK_SELECTION		200112L
-#define _POSIX_PRIORITIZED_IO		1
-#define _POSIX_PRIORITY_SCHEDULING	1
-#define _POSIX_REALTIME_SIGNALS		1
-#define _POSIX_SEMAPHORES		1
-#define _POSIX_SHARED_MEMORY_OBJECTS	1
-#define _POSIX_SYNCHRONIZED_IO		1
-#define _POSIX_TIMERS			1
-#define _POSIX_BARRIERS                 200112L
-#define _POSIX_READER_WRITER_LOCKS      200112L
-#define _POSIX_SPIN_LOCKS               200112L
-
-
-/* In P1003.1b but defined by drafts at least as early as P1003.1c/D10  */
-#define _POSIX_THREADS				1
-#define _POSIX_THREAD_ATTR_STACKADDR		1
-#define _POSIX_THREAD_ATTR_STACKSIZE		1
-#define _POSIX_THREAD_PRIORITY_SCHEDULING	1
-#define _POSIX_THREAD_PRIO_INHERIT		1
-#define _POSIX_THREAD_PRIO_PROTECT		1
-#define _POSIX_THREAD_PROCESS_SHARED		1
-#define _POSIX_THREAD_SAFE_FUNCTIONS		1
-
-/* P1003.4b/D8 defines the constants below this comment. */
-#define _POSIX_SPAWN				1
-#define _POSIX_TIMEOUTS				1
-#define _POSIX_CPUTIME				1
-#define _POSIX_THREAD_CPUTIME			1
-#define _POSIX_SPORADIC_SERVER			1
-#define _POSIX_THREAD_SPORADIC_SERVER		1
-#define _POSIX_DEVICE_CONTROL			1
-#define _POSIX_DEVCTL_DIRECTION			1
-#define _POSIX_INTERRUPT_CONTROL		1
-#define _POSIX_ADVISORY_INFO			1
-
-/* UNIX98 added some new pthread mutex attributes */
-#define _UNIX98_THREAD_MUTEX_ATTRIBUTES         1
-
-/* POSIX 1003.26-2003 defined device control method */
-#define _POSIX_26_VERSION			200312L
-
-#endif
-
-/* XMK loosely adheres to POSIX -- 1003.1 */
-#ifdef __XMK__
-#define _POSIX_THREADS				1
-#define _POSIX_THREAD_PRIORITY_SCHEDULING	1
-#endif
-
-
-#ifdef __svr4__
-# define _POSIX_JOB_CONTROL     1
-# define _POSIX_SAVED_IDS       1
-# define _POSIX_VERSION 199009L
-#endif
-
-#ifdef __CYGWIN__
-
-#if __POSIX_VISIBLE >= 200809
-#define _POSIX_VERSION				200809L
-#define _POSIX2_VERSION				200809L
-#elif __POSIX_VISIBLE >= 200112
-#define _POSIX_VERSION				200112L
-#define _POSIX2_VERSION				200112L
-#elif __POSIX_VISIBLE >= 199506
-#define _POSIX_VERSION				199506L
-#define _POSIX2_VERSION				199506L
-#elif __POSIX_VISIBLE >= 199309
-#define _POSIX_VERSION				199309L
-#define _POSIX2_VERSION				199209L
-#elif __POSIX_VISIBLE >= 199209
-#define _POSIX_VERSION				199009L
-#define _POSIX2_VERSION				199209L
-#elif __POSIX_VISIBLE
-#define _POSIX_VERSION				199009L
-#endif
-#if __XSI_VISIBLE >= 4
-#define _XOPEN_VERSION				__XSI_VISIBLE
-#endif
-
-#define _POSIX_ADVISORY_INFO			200809L
-#define _POSIX_ASYNCHRONOUS_IO			200809L
-#define _POSIX_BARRIERS				200809L
-#define _POSIX_CHOWN_RESTRICTED			     1
-#define _POSIX_CLOCK_SELECTION			200809L
-#define _POSIX_CPUTIME				200809L
-#define _POSIX_FSYNC				200809L
-#define _POSIX_IPV6				200809L
-#define _POSIX_JOB_CONTROL			     1
-#define _POSIX_MAPPED_FILES			200809L
-/* #define _POSIX_MEMLOCK			    -1 */
-#define _POSIX_MEMLOCK_RANGE			200809L
-#define _POSIX_MEMORY_PROTECTION		200809L
-#define _POSIX_MESSAGE_PASSING			200809L
-#define _POSIX_MONOTONIC_CLOCK			200809L
-#define _POSIX_NO_TRUNC				     1
-/* #define _POSIX_PRIORITIZED_IO		    -1 */
-#define _POSIX_PRIORITY_SCHEDULING		200809L
-#define _POSIX_RAW_SOCKETS			200809L
-#define _POSIX_READER_WRITER_LOCKS		200809L
-#define _POSIX_REALTIME_SIGNALS			200809L
-#define _POSIX_REGEXP				     1
-#define _POSIX_SAVED_IDS			     1
-#define _POSIX_SEMAPHORES			200809L
-#define _POSIX_SHARED_MEMORY_OBJECTS		200809L
-#define _POSIX_SHELL				     1
-#define _POSIX_SPAWN				200809L
-#define _POSIX_SPIN_LOCKS			200809L
-/* #define _POSIX_SPORADIC_SERVER		    -1 */
-#define _POSIX_SYNCHRONIZED_IO			200809L
-#define _POSIX_THREAD_ATTR_STACKADDR		200809L
-#define _POSIX_THREAD_ATTR_STACKSIZE		200809L
-#define _POSIX_THREAD_CPUTIME			200809L
-/* #define _POSIX_THREAD_PRIO_INHERIT		    -1 */
-/* #define _POSIX_THREAD_PRIO_PROTECT		    -1 */
-#define _POSIX_THREAD_PRIORITY_SCHEDULING	200809L
-#define _POSIX_THREAD_PROCESS_SHARED		200809L
-#define _POSIX_THREAD_SAFE_FUNCTIONS		200809L
-/* #define _POSIX_THREAD_SPORADIC_SERVER	    -1 */
-#define _POSIX_THREADS				200809L
-#define _POSIX_TIMEOUTS				200809L
-#define _POSIX_TIMERS				200809L
-/* #define _POSIX_TRACE				    -1 */
-/* #define _POSIX_TRACE_EVENT_FILTER		    -1 */
-/* #define _POSIX_TRACE_INHERIT			    -1 */
-/* #define _POSIX_TRACE_LOG			    -1 */
-/* #define _POSIX_TYPED_MEMORY_OBJECTS		    -1 */
-#define _POSIX_VDISABLE				   '\0'
-
-#if __POSIX_VISIBLE >= 2
-#define _POSIX2_C_VERSION			_POSIX2_VERSION
-#define _POSIX2_C_BIND				_POSIX2_VERSION
-#define _POSIX2_C_DEV				_POSIX2_VERSION
-#define _POSIX2_CHAR_TERM			_POSIX2_VERSION
-/* #define _POSIX2_FORT_DEV			    -1 */
-/* #define _POSIX2_FORT_RUN			    -1 */
-/* #define _POSIX2_LOCALEDEF			    -1 */
-/* #define _POSIX2_PBS				    -1 */
-/* #define _POSIX2_PBS_ACCOUNTING		    -1 */
-/* #define _POSIX2_PBS_CHECKPOINT		    -1 */
-/* #define _POSIX2_PBS_LOCATE			    -1 */
-/* #define _POSIX2_PBS_MESSAGE			    -1 */
-/* #define _POSIX2_PBS_TRACK			    -1 */
-#define _POSIX2_SW_DEV				_POSIX2_VERSION
-#define _POSIX2_UPE				_POSIX2_VERSION
-#endif /* __POSIX_VISIBLE >= 2 */
-
-#define _POSIX_V6_ILP32_OFF32			    -1
-#ifdef __LP64__
-#define _POSIX_V6_ILP32_OFFBIG			    -1
-#define _POSIX_V6_LP64_OFF64			     1
-#define _POSIX_V6_LPBIG_OFFBIG			     1
-#else
-#define _POSIX_V6_ILP32_OFFBIG			     1
-#define _POSIX_V6_LP64_OFF64			    -1
-#define _POSIX_V6_LPBIG_OFFBIG			    -1
-#endif
-#define _POSIX_V7_ILP32_OFF32			_POSIX_V6_ILP32_OFF32
-#define _POSIX_V7_ILP32_OFFBIG			_POSIX_V6_ILP32_OFFBIG
-#define _POSIX_V7_LP64_OFF64			_POSIX_V6_LP64_OFF64
-#define _POSIX_V7_LPBIG_OFFBIG			_POSIX_V6_LPBIG_OFFBIG
-#define _XBS5_ILP32_OFF32			_POSIX_V6_ILP32_OFF32
-#define _XBS5_ILP32_OFFBIG			_POSIX_V6_ILP32_OFFBIG
-#define _XBS5_LP64_OFF64			_POSIX_V6_LP64_OFF64
-#define _XBS5_LPBIG_OFFBIG			_POSIX_V6_LPBIG_OFFBIG
-
-#if __XSI_VISIBLE
-#define _XOPEN_CRYPT				     1
-#define _XOPEN_ENH_I18N				     1
-/* #define _XOPEN_LEGACY			    -1 */
-/* #define _XOPEN_REALTIME			    -1 */
-/* #define _XOPEN_REALTIME_THREADS		    -1 */
-#define _XOPEN_SHM				     1
-/* #define _XOPEN_STREAMS			    -1 */
-/* #define _XOPEN_UNIX				    -1 */
-#endif /* __XSI_VISIBLE */
-
-/* The value corresponds to UNICODE version 5.2, which is the current
-   state of newlib's wide char conversion functions. */
-#define __STDC_ISO_10646__ 200910L
-
-#endif /* __CYGWIN__ */
-
-#ifdef __cplusplus
-}
-#endif
-#endif /* _SYS_FEATURES_H */

src/include/sys/lock.h

@@ -1,69 +0,0 @@
-#ifndef __SYS_LOCK_H__
-#define __SYS_LOCK_H__
-
-/* dummy lock routines for single-threaded aps */
-
-#include <newlib.h>
-#include <_ansi.h>
-
-#if !defined(_RETARGETABLE_LOCKING)
-
-typedef int _LOCK_T;
-typedef int _LOCK_RECURSIVE_T;
-
-#define __LOCK_INIT(class,lock) static int lock = 0;
-#define __LOCK_INIT_RECURSIVE(class,lock) static int lock = 0;
-#define __lock_init(lock) ((void) 0)
-#define __lock_init_recursive(lock) ((void) 0)
-#define __lock_close(lock) ((void) 0)
-#define __lock_close_recursive(lock) ((void) 0)
-#define __lock_acquire(lock) ((void) 0)
-#define __lock_acquire_recursive(lock) ((void) 0)
-#define __lock_try_acquire(lock) ((void) 0)
-#define __lock_try_acquire_recursive(lock) ((void) 0)
-#define __lock_release(lock) ((void) 0)
-#define __lock_release_recursive(lock) ((void) 0)
-
-#else
-
-#ifdef __cplusplus
-extern "C" {
-#endif
-
-struct __lock;
-typedef struct __lock * _LOCK_T;
-#define _LOCK_RECURSIVE_T _LOCK_T
-
-#define __LOCK_INIT(class,lock) extern struct __lock __lock_ ## lock; \
-	class _LOCK_T lock = &__lock_ ## lock
-#define __LOCK_INIT_RECURSIVE(class,lock) __LOCK_INIT(class,lock)
-
-extern void __retarget_lock_init(_LOCK_T *lock);
-#define __lock_init(lock) __retarget_lock_init(&lock)
-extern void __retarget_lock_init_recursive(_LOCK_T *lock);
-#define __lock_init_recursive(lock) __retarget_lock_init_recursive(&lock)
-extern void __retarget_lock_close(_LOCK_T lock);
-#define __lock_close(lock) __retarget_lock_close(lock)
-extern void __retarget_lock_close_recursive(_LOCK_T lock);
-#define __lock_close_recursive(lock) __retarget_lock_close_recursive(lock)
-extern void __retarget_lock_acquire(_LOCK_T lock);
-#define __lock_acquire(lock) __retarget_lock_acquire(lock)
-extern void __retarget_lock_acquire_recursive(_LOCK_T lock);
-#define __lock_acquire_recursive(lock) __retarget_lock_acquire_recursive(lock)
-extern int __retarget_lock_try_acquire(_LOCK_T lock);
-#define __lock_try_acquire(lock) __retarget_lock_try_acquire(lock)
-extern int __retarget_lock_try_acquire_recursive(_LOCK_T lock);
-#define __lock_try_acquire_recursive(lock) \
-  __retarget_lock_try_acquire_recursive(lock)
-extern void __retarget_lock_release(_LOCK_T lock);
-#define __lock_release(lock) __retarget_lock_release(lock)
-extern void __retarget_lock_release_recursive(_LOCK_T lock);
-#define __lock_release_recursive(lock) __retarget_lock_release_recursive(lock)
-
-#ifdef __cplusplus
-}
-#endif
-
-#endif /* !defined(_RETARGETABLE_LOCKING) */
-
-#endif /* __SYS_LOCK_H__ */

src/include/sys/reent.h

@@ -1,842 +0,0 @@
-/* This header file provides the reentrancy.  */
-
-/* WARNING: All identifiers here must begin with an underscore.  This file is
-   included by stdio.h and others and we therefore must only use identifiers
-   in the namespace allotted to us.  */
-
-#ifndef _SYS_REENT_H_
-#ifdef __cplusplus
-extern "C" {
-#endif
-#define _SYS_REENT_H_
-
-#include <_ansi.h>
-#include <stddef.h>
-#include <sys/_types.h>
-
-#define _NULL 0
-
-#ifndef __Long
-#if __LONG_MAX__ == 2147483647L
-#define __Long long
-typedef unsigned __Long __ULong;
-#elif __INT_MAX__ == 2147483647
-#define __Long int
-typedef unsigned __Long __ULong;
-#endif
-#endif
-
-#if !defined( __Long)
-#include <sys/types.h>
-#endif
-
-#ifndef __Long
-#define __Long __int32_t
-typedef __uint32_t __ULong;
-#endif
-
-struct _reent;
-
-struct __locale_t;
-
-/*
- * If _REENT_SMALL is defined, we make struct _reent as small as possible,
- * by having nearly everything possible allocated at first use.
- */
-
-struct _Bigint
-{
-  struct _Bigint *_next;
-  int _k, _maxwds, _sign, _wds;
-  __ULong _x[1];
-};
-
-/* needed by reentrant structure */
-struct __tm
-{
-  int   __tm_sec;
-  int   __tm_min;
-  int   __tm_hour;
-  int   __tm_mday;
-  int   __tm_mon;
-  int   __tm_year;
-  int   __tm_wday;
-  int   __tm_yday;
-  int   __tm_isdst;
-};
-
-/*
- * atexit() support.
- */
-
-#define	_ATEXIT_SIZE 32	/* must be at least 32 to guarantee ANSI conformance */
-
-struct _on_exit_args {
-	void *  _fnargs[_ATEXIT_SIZE];	        /* user fn args */
-	void *	_dso_handle[_ATEXIT_SIZE];
-	/* Bitmask is set if user function takes arguments.  */
-	__ULong _fntypes;           	        /* type of exit routine -
-				   Must have at least _ATEXIT_SIZE bits */
-	/* Bitmask is set if function was registered via __cxa_atexit.  */
-	__ULong _is_cxa;
-};
-
-#ifdef _REENT_SMALL
-struct _atexit {
-	struct	_atexit *_next;			/* next in list */
-	int	_ind;				/* next index in this table */
-	void	(*_fns[_ATEXIT_SIZE])(void);	/* the table itself */
-        struct _on_exit_args * _on_exit_args_ptr;
-};
-# define _ATEXIT_INIT {_NULL, 0, {_NULL}, _NULL}
-#else
-struct _atexit {
-	struct	_atexit *_next;			/* next in list */
-	int	_ind;				/* next index in this table */
-	/* Some entries may already have been called, and will be NULL.  */
-	void	(*_fns[_ATEXIT_SIZE])(void);	/* the table itself */
-        struct _on_exit_args _on_exit_args;
-};
-# define _ATEXIT_INIT {_NULL, 0, {_NULL}, {{_NULL}, {_NULL}, 0, 0}}
-#endif
-
-#ifdef _REENT_GLOBAL_ATEXIT
-# define _REENT_INIT_ATEXIT
-#else
-# define _REENT_INIT_ATEXIT \
-  _NULL, _ATEXIT_INIT,
-#endif
-
-/*
- * Stdio buffers.
- *
- * This and __FILE are defined here because we need them for struct _reent,
- * but we don't want stdio.h included when stdlib.h is.
- */
-
-struct __sbuf {
-	unsigned char *_base;
-	int	_size;
-};
-
-/*
- * Stdio state variables.
- *
- * The following always hold:
- *
- *	if (_flags&(__SLBF|__SWR)) == (__SLBF|__SWR),
- *		_lbfsize is -_bf._size, else _lbfsize is 0
- *	if _flags&__SRD, _w is 0
- *	if _flags&__SWR, _r is 0
- *
- * This ensures that the getc and putc macros (or inline functions) never
- * try to write or read from a file that is in `read' or `write' mode.
- * (Moreover, they can, and do, automatically switch from read mode to
- * write mode, and back, on "r+" and "w+" files.)
- *
- * _lbfsize is used only to make the inline line-buffered output stream
- * code as compact as possible.
- *
- * _ub, _up, and _ur are used when ungetc() pushes back more characters
- * than fit in the current _bf, or when ungetc() pushes back a character
- * that does not match the previous one in _bf.  When this happens,
- * _ub._base becomes non-nil (i.e., a stream has ungetc() data iff
- * _ub._base!=NULL) and _up and _ur save the current values of _p and _r.
- */
-
-#if defined(_REENT_SMALL) && !defined(_REENT_GLOBAL_STDIO_STREAMS)
-/*
- * struct __sFILE_fake is the start of a struct __sFILE, with only the
- * minimal fields allocated.  In __sinit() we really allocate the 3
- * standard streams, etc., and point away from this fake.
- */
-struct __sFILE_fake {
-  unsigned char *_p;	/* current position in (some) buffer */
-  int	_r;		/* read space left for getc() */
-  int	_w;		/* write space left for putc() */
-  short	_flags;		/* flags, below; this FILE is free if 0 */
-  short	_file;		/* fileno, if Unix descriptor, else -1 */
-  struct __sbuf _bf;	/* the buffer (at least 1 byte, if !NULL) */
-  int	_lbfsize;	/* 0 or -_bf._size, for inline putc */
-
-  struct _reent *_data;
-};
-
-/* Following is needed both in libc/stdio and libc/stdlib so we put it
- * here instead of libc/stdio/local.h where it was previously. */
-
-extern void   __sinit (struct _reent *);
-
-# define _REENT_SMALL_CHECK_INIT(ptr)		\
-  do						\
-    {						\
-      if ((ptr) && !(ptr)->__sdidinit)		\
-	__sinit (ptr);				\
-    }						\
-  while (0)
-#else /* _REENT_SMALL && !_REENT_GLOBAL_STDIO_STREAMS */
-# define _REENT_SMALL_CHECK_INIT(ptr) /* nothing */
-#endif /* _REENT_SMALL && !_REENT_GLOBAL_STDIO_STREAMS */
-
-struct __sFILE {
-  unsigned char *_p;	/* current position in (some) buffer */
-  int	_r;		/* read space left for getc() */
-  int	_w;		/* write space left for putc() */
-  short	_flags;		/* flags, below; this FILE is free if 0 */
-  short	_file;		/* fileno, if Unix descriptor, else -1 */
-  struct __sbuf _bf;	/* the buffer (at least 1 byte, if !NULL) */
-  int	_lbfsize;	/* 0 or -_bf._size, for inline putc */
-
-#ifdef _REENT_SMALL
-  struct _reent *_data;
-#endif
-
-  /* operations */
-  void *	_cookie;	/* cookie passed to io functions */
-
-  _READ_WRITE_RETURN_TYPE (*_read) (struct _reent *, void *,
-					   char *, _READ_WRITE_BUFSIZE_TYPE);
-  _READ_WRITE_RETURN_TYPE (*_write) (struct _reent *, void *,
-					    const char *,
-					    _READ_WRITE_BUFSIZE_TYPE);
-  _fpos_t (*_seek) (struct _reent *, void *, _fpos_t, int);
-  int (*_close) (struct _reent *, void *);
-
-  /* separate buffer for long sequences of ungetc() */
-  struct __sbuf _ub;	/* ungetc buffer */
-  unsigned char *_up;	/* saved _p when _p is doing ungetc data */
-  int	_ur;		/* saved _r when _r is counting ungetc data */
-
-  /* tricks to meet minimum requirements even when malloc() fails */
-  unsigned char _ubuf[3];	/* guarantee an ungetc() buffer */
-  unsigned char _nbuf[1];	/* guarantee a getc() buffer */
-
-  /* separate buffer for fgetline() when line crosses buffer boundary */
-  struct __sbuf _lb;	/* buffer for fgetline() */
-
-  /* Unix stdio files get aligned to block boundaries on fseek() */
-  int	_blksize;	/* stat.st_blksize (may be != _bf._size) */
-  _off_t _offset;	/* current lseek offset */
-
-#ifndef _REENT_SMALL
-  struct _reent *_data;	/* Here for binary compatibility? Remove? */
-#endif
-
-#ifndef __SINGLE_THREAD__
-  _flock_t _lock;	/* for thread-safety locking */
-#endif
-  _mbstate_t _mbstate;	/* for wide char stdio functions. */
-  int   _flags2;        /* for future use */
-};
-
-#ifdef __CUSTOM_FILE_IO__
-
-/* Get custom _FILE definition.  */
-#include <sys/custom_file.h>
-
-#else /* !__CUSTOM_FILE_IO__ */
-#ifdef __LARGE64_FILES
-struct __sFILE64 {
-  unsigned char *_p;	/* current position in (some) buffer */
-  int	_r;		/* read space left for getc() */
-  int	_w;		/* write space left for putc() */
-  short	_flags;		/* flags, below; this FILE is free if 0 */
-  short	_file;		/* fileno, if Unix descriptor, else -1 */
-  struct __sbuf _bf;	/* the buffer (at least 1 byte, if !NULL) */
-  int	_lbfsize;	/* 0 or -_bf._size, for inline putc */
-
-  struct _reent *_data;
-
-  /* operations */
-  void *	_cookie;	/* cookie passed to io functions */
-
-  _READ_WRITE_RETURN_TYPE (*_read) (struct _reent *, void *,
-					   char *, _READ_WRITE_BUFSIZE_TYPE);
-  _READ_WRITE_RETURN_TYPE (*_write) (struct _reent *, void *,
-					    const char *,
-					    _READ_WRITE_BUFSIZE_TYPE);
-  _fpos_t (*_seek) (struct _reent *, void *, _fpos_t, int);
-  int (*_close) (struct _reent *, void *);
-
-  /* separate buffer for long sequences of ungetc() */
-  struct __sbuf _ub;	/* ungetc buffer */
-  unsigned char *_up;	/* saved _p when _p is doing ungetc data */
-  int	_ur;		/* saved _r when _r is counting ungetc data */
-
-  /* tricks to meet minimum requirements even when malloc() fails */
-  unsigned char _ubuf[3];	/* guarantee an ungetc() buffer */
-  unsigned char _nbuf[1];	/* guarantee a getc() buffer */
-
-  /* separate buffer for fgetline() when line crosses buffer boundary */
-  struct __sbuf _lb;	/* buffer for fgetline() */
-
-  /* Unix stdio files get aligned to block boundaries on fseek() */
-  int	_blksize;	/* stat.st_blksize (may be != _bf._size) */
-  int   _flags2;        /* for future use */
-
-  _off64_t _offset;     /* current lseek offset */
-  _fpos64_t (*_seek64) (struct _reent *, void *, _fpos64_t, int);
-
-#ifndef __SINGLE_THREAD__
-  _flock_t _lock;	/* for thread-safety locking */
-#endif
-  _mbstate_t _mbstate;	/* for wide char stdio functions. */
-};
-typedef struct __sFILE64 __FILE;
-#else
-typedef struct __sFILE   __FILE;
-#endif /* __LARGE64_FILES */
-#endif /* !__CUSTOM_FILE_IO__ */
-
-struct _glue
-{
-  struct _glue *_next;
-  int _niobs;
-  __FILE *_iobs;
-};
-
-/*
- * rand48 family support
- *
- * Copyright (c) 1993 Martin Birgmeier
- * All rights reserved.
- *
- * You may redistribute unmodified or modified versions of this source
- * code provided that the above copyright notice and this and the
- * following conditions are retained.
- *
- * This software is provided ``as is'', and comes with no warranties
- * of any kind. I shall in no event be liable for anything that happens
- * to anyone/anything when using this software.
- */
-#define        _RAND48_SEED_0  (0x330e)
-#define        _RAND48_SEED_1  (0xabcd)
-#define        _RAND48_SEED_2  (0x1234)
-#define        _RAND48_MULT_0  (0xe66d)
-#define        _RAND48_MULT_1  (0xdeec)
-#define        _RAND48_MULT_2  (0x0005)
-#define        _RAND48_ADD     (0x000b)
-struct _rand48 {
-  unsigned short _seed[3];
-  unsigned short _mult[3];
-  unsigned short _add;
-#ifdef _REENT_SMALL
-  /* Put this in here as well, for good luck.  */
-  __extension__ unsigned long long _rand_next;
-#endif
-};
-
-/* How big the some arrays are.  */
-#define _REENT_EMERGENCY_SIZE 25
-#define _REENT_ASCTIME_SIZE 26
-#define _REENT_SIGNAL_SIZE 24
-
-/*
- * struct _reent
- *
- * This structure contains *all* globals needed by the library.
- * It's raison d'etre is to facilitate threads by making all library routines
- * reentrant.  IE: All state information is contained here.
- */
-
-#ifdef _REENT_SMALL
-
-struct _mprec
-{
-  /* used by mprec routines */
-  struct _Bigint *_result;
-  int _result_k;
-  struct _Bigint *_p5s;
-  struct _Bigint **_freelist;
-};
-
-
-struct _misc_reent
-{
-  /* miscellaneous reentrant data */
-  char *_strtok_last;
-  _mbstate_t _mblen_state;
-  _mbstate_t _wctomb_state;
-  _mbstate_t _mbtowc_state;
-  char _l64a_buf[8];
-  int _getdate_err;
-  _mbstate_t _mbrlen_state;
-  _mbstate_t _mbrtowc_state;
-  _mbstate_t _mbsrtowcs_state;
-  _mbstate_t _wcrtomb_state;
-  _mbstate_t _wcsrtombs_state;
-};
-
-/* This version of _reent is laid out with "int"s in pairs, to help
- * ports with 16-bit int's but 32-bit pointers, align nicely.  */
-struct _reent
-{
-  /* As an exception to the above put _errno first for binary
-     compatibility with non _REENT_SMALL targets.  */
-  int _errno;			/* local copy of errno */
-
-  /* FILE is a big struct and may change over time.  To try to achieve binary
-     compatibility with future versions, put stdin,stdout,stderr here.
-     These are pointers into member __sf defined below.  */
-  __FILE *_stdin, *_stdout, *_stderr;	/* XXX */
-
-  int  _inc;			/* used by tmpnam */
-
-  char *_emergency;
-
-  int __sdidinit;		/* 1 means stdio has been init'd */
-
-  int _unspecified_locale_info;	/* unused, reserved for locale stuff */
-  struct __locale_t *_locale;/* per-thread locale */
-
-  struct _mprec *_mp;
-
-  void (*__cleanup) (struct _reent *);
-
-  int _gamma_signgam;
-
-  /* used by some fp conversion routines */
-  int _cvtlen;			/* should be size_t */
-  char *_cvtbuf;
-
-  struct _rand48 *_r48;
-  struct __tm *_localtime_buf;
-  char *_asctime_buf;
-
-  /* signal info */
-  void (**(_sig_func))(int);
-
-# ifndef _REENT_GLOBAL_ATEXIT
-  /* atexit stuff */
-  struct _atexit *_atexit;
-  struct _atexit _atexit0;
-# endif
-
-  struct _glue __sglue;			/* root of glue chain */
-  __FILE *__sf;			        /* file descriptors */
-  struct _misc_reent *_misc;            /* strtok, multibyte states */
-  char *_signal_buf;                    /* strsignal */
-};
-
-#ifdef _REENT_GLOBAL_STDIO_STREAMS
-extern __FILE __sf[3];
-
-# define _REENT_INIT(var) \
-  { 0, \
-    &__sf[0], \
-    &__sf[1], \
-    &__sf[2], \
-    0,   \
-    _NULL, \
-    0, \
-    0, \
-    _NULL, \
-    _NULL, \
-    _NULL, \
-    0, \
-    0, \
-    _NULL, \
-    _NULL, \
-    _NULL, \
-    _NULL, \
-    _NULL, \
-    _REENT_INIT_ATEXIT \
-    {_NULL, 0, _NULL}, \
-    _NULL, \
-    _NULL, \
-    _NULL \
-  }
-
-#define _REENT_INIT_PTR_ZEROED(var) \
-  { (var)->_stdin = &__sf[0]; \
-    (var)->_stdout = &__sf[1]; \
-    (var)->_stderr = &__sf[2]; \
-  }
-
-#else /* _REENT_GLOBAL_STDIO_STREAMS */
-
-extern const struct __sFILE_fake __sf_fake_stdin;
-extern const struct __sFILE_fake __sf_fake_stdout;
-extern const struct __sFILE_fake __sf_fake_stderr;
-
-# define _REENT_INIT(var) \
-  { 0, \
-    (__FILE *)&__sf_fake_stdin, \
-    (__FILE *)&__sf_fake_stdout, \
-    (__FILE *)&__sf_fake_stderr, \
-    0, \
-    _NULL, \
-    0, \
-    0, \
-    _NULL, \
-    _NULL, \
-    _NULL, \
-    0, \
-    0, \
-    _NULL, \
-    _NULL, \
-    _NULL, \
-    _NULL, \
-    _NULL, \
-    _REENT_INIT_ATEXIT \
-    {_NULL, 0, _NULL}, \
-    _NULL, \
-    _NULL, \
-    _NULL \
-  }
-
-#define _REENT_INIT_PTR_ZEROED(var) \
-  { (var)->_stdin = (__FILE *)&__sf_fake_stdin; \
-    (var)->_stdout = (__FILE *)&__sf_fake_stdout; \
-    (var)->_stderr = (__FILE *)&__sf_fake_stderr; \
-  }
-
-#endif /* _REENT_GLOBAL_STDIO_STREAMS */
-
-/* Only add assert() calls if we are specified to debug.  */
-#ifdef _REENT_CHECK_DEBUG
-#include <assert.h>
-#define __reent_assert(x) assert(x)
-#else
-#define __reent_assert(x) ((void)0)
-#endif
-
-#ifdef __CUSTOM_FILE_IO__
-#error Custom FILE I/O and _REENT_SMALL not currently supported.
-#endif
-
-/* Generic _REENT check macro.  */
-#define _REENT_CHECK(var, what, type, size, init) do { \
-  struct _reent *_r = (var); \
-  if (_r->what == NULL) { \
-    _r->what = (type)malloc(size); \
-    __reent_assert(_r->what); \
-    init; \
-  } \
-} while (0)
-
-#define _REENT_CHECK_TM(var) \
-  _REENT_CHECK(var, _localtime_buf, struct __tm *, sizeof *((var)->_localtime_buf), \
-    /* nothing */)
-
-#define _REENT_CHECK_ASCTIME_BUF(var) \
-  _REENT_CHECK(var, _asctime_buf, char *, _REENT_ASCTIME_SIZE, \
-    memset((var)->_asctime_buf, 0, _REENT_ASCTIME_SIZE))
-
-/* Handle the dynamically allocated rand48 structure. */
-#define _REENT_INIT_RAND48(var) do { \
-  struct _reent *_r = (var); \
-  _r->_r48->_seed[0] = _RAND48_SEED_0; \
-  _r->_r48->_seed[1] = _RAND48_SEED_1; \
-  _r->_r48->_seed[2] = _RAND48_SEED_2; \
-  _r->_r48->_mult[0] = _RAND48_MULT_0; \
-  _r->_r48->_mult[1] = _RAND48_MULT_1; \
-  _r->_r48->_mult[2] = _RAND48_MULT_2; \
-  _r->_r48->_add = _RAND48_ADD; \
-  _r->_r48->_rand_next = 1; \
-} while (0)
-#define _REENT_CHECK_RAND48(var) \
-  _REENT_CHECK(var, _r48, struct _rand48 *, sizeof *((var)->_r48), _REENT_INIT_RAND48((var)))
-
-#define _REENT_INIT_MP(var) do { \
-  struct _reent *_r = (var); \
-  _r->_mp->_result_k = 0; \
-  _r->_mp->_result = _r->_mp->_p5s = _NULL; \
-  _r->_mp->_freelist = _NULL; \
-} while (0)
-#define _REENT_CHECK_MP(var) \
-  _REENT_CHECK(var, _mp, struct _mprec *, sizeof *((var)->_mp), _REENT_INIT_MP(var))
-
-#define _REENT_CHECK_EMERGENCY(var) \
-  _REENT_CHECK(var, _emergency, char *, _REENT_EMERGENCY_SIZE, /* nothing */)
-
-#define _REENT_INIT_MISC(var) do { \
-  struct _reent *_r = (var); \
-  _r->_misc->_strtok_last = _NULL; \
-  _r->_misc->_mblen_state.__count = 0; \
-  _r->_misc->_mblen_state.__value.__wch = 0; \
-  _r->_misc->_wctomb_state.__count = 0; \
-  _r->_misc->_wctomb_state.__value.__wch = 0; \
-  _r->_misc->_mbtowc_state.__count = 0; \
-  _r->_misc->_mbtowc_state.__value.__wch = 0; \
-  _r->_misc->_mbrlen_state.__count = 0; \
-  _r->_misc->_mbrlen_state.__value.__wch = 0; \
-  _r->_misc->_mbrtowc_state.__count = 0; \
-  _r->_misc->_mbrtowc_state.__value.__wch = 0; \
-  _r->_misc->_mbsrtowcs_state.__count = 0; \
-  _r->_misc->_mbsrtowcs_state.__value.__wch = 0; \
-  _r->_misc->_wcrtomb_state.__count = 0; \
-  _r->_misc->_wcrtomb_state.__value.__wch = 0; \
-  _r->_misc->_wcsrtombs_state.__count = 0; \
-  _r->_misc->_wcsrtombs_state.__value.__wch = 0; \
-  _r->_misc->_l64a_buf[0] = '\0'; \
-  _r->_misc->_getdate_err = 0; \
-} while (0)
-#define _REENT_CHECK_MISC(var) \
-  _REENT_CHECK(var, _misc, struct _misc_reent *, sizeof *((var)->_misc), _REENT_INIT_MISC(var))
-
-#define _REENT_CHECK_SIGNAL_BUF(var) \
-  _REENT_CHECK(var, _signal_buf, char *, _REENT_SIGNAL_SIZE, /* nothing */)
-
-#define _REENT_SIGNGAM(ptr)	((ptr)->_gamma_signgam)
-#define _REENT_RAND_NEXT(ptr)	((ptr)->_r48->_rand_next)
-#define _REENT_RAND48_SEED(ptr)	((ptr)->_r48->_seed)
-#define _REENT_RAND48_MULT(ptr)	((ptr)->_r48->_mult)
-#define _REENT_RAND48_ADD(ptr)	((ptr)->_r48->_add)
-#define _REENT_MP_RESULT(ptr)	((ptr)->_mp->_result)
-#define _REENT_MP_RESULT_K(ptr)	((ptr)->_mp->_result_k)
-#define _REENT_MP_P5S(ptr)	((ptr)->_mp->_p5s)
-#define _REENT_MP_FREELIST(ptr)	((ptr)->_mp->_freelist)
-#define _REENT_ASCTIME_BUF(ptr)	((ptr)->_asctime_buf)
-#define _REENT_TM(ptr)		((ptr)->_localtime_buf)
-#define _REENT_EMERGENCY(ptr)	((ptr)->_emergency)
-#define _REENT_STRTOK_LAST(ptr)	((ptr)->_misc->_strtok_last)
-#define _REENT_MBLEN_STATE(ptr)	((ptr)->_misc->_mblen_state)
-#define _REENT_MBTOWC_STATE(ptr)((ptr)->_misc->_mbtowc_state)
-#define _REENT_WCTOMB_STATE(ptr)((ptr)->_misc->_wctomb_state)
-#define _REENT_MBRLEN_STATE(ptr) ((ptr)->_misc->_mbrlen_state)
-#define _REENT_MBRTOWC_STATE(ptr) ((ptr)->_misc->_mbrtowc_state)
-#define _REENT_MBSRTOWCS_STATE(ptr) ((ptr)->_misc->_mbsrtowcs_state)
-#define _REENT_WCRTOMB_STATE(ptr) ((ptr)->_misc->_wcrtomb_state)
-#define _REENT_WCSRTOMBS_STATE(ptr) ((ptr)->_misc->_wcsrtombs_state)
-#define _REENT_L64A_BUF(ptr)    ((ptr)->_misc->_l64a_buf)
-#define _REENT_GETDATE_ERR_P(ptr) (&((ptr)->_misc->_getdate_err))
-#define _REENT_SIGNAL_BUF(ptr)  ((ptr)->_signal_buf)
-
-#else /* !_REENT_SMALL */
-
-struct _reent
-{
-  int _errno;			/* local copy of errno */
-
-  /* FILE is a big struct and may change over time.  To try to achieve binary
-     compatibility with future versions, put stdin,stdout,stderr here.
-     These are pointers into member __sf defined below.  */
-  __FILE *_stdin, *_stdout, *_stderr;
-
-  int  _inc;			/* used by tmpnam */
-  char _emergency[_REENT_EMERGENCY_SIZE];
-
-  /* TODO */
-  int _unspecified_locale_info;	/* unused, reserved for locale stuff */
-  struct __locale_t *_locale;/* per-thread locale */
-
-  int __sdidinit;		/* 1 means stdio has been init'd */
-
-  void (*__cleanup) (struct _reent *);
-
-  /* used by mprec routines */
-  struct _Bigint *_result;
-  int _result_k;
-  struct _Bigint *_p5s;
-  struct _Bigint **_freelist;
-
-  /* used by some fp conversion routines */
-  int _cvtlen;			/* should be size_t */
-  char *_cvtbuf;
-
-  union
-    {
-      struct
-        {
-          unsigned int _unused_rand;
-          char * _strtok_last;
-          char _asctime_buf[_REENT_ASCTIME_SIZE];
-          struct __tm _localtime_buf;
-          int _gamma_signgam;
-          __extension__ unsigned long long _rand_next;
-          struct _rand48 _r48;
-          _mbstate_t _mblen_state;
-          _mbstate_t _mbtowc_state;
-          _mbstate_t _wctomb_state;
-          char _l64a_buf[8];
-          char _signal_buf[_REENT_SIGNAL_SIZE];
-          int _getdate_err;
-          _mbstate_t _mbrlen_state;
-          _mbstate_t _mbrtowc_state;
-          _mbstate_t _mbsrtowcs_state;
-          _mbstate_t _wcrtomb_state;
-          _mbstate_t _wcsrtombs_state;
-	  int _h_errno;
-        } _reent;
-  /* Two next two fields were once used by malloc.  They are no longer
-     used. They are used to preserve the space used before so as to
-     allow addition of new reent fields and keep binary compatibility.   */
-      struct
-        {
-#define _N_LISTS 30
-          unsigned char * _nextf[_N_LISTS];
-          unsigned int _nmalloc[_N_LISTS];
-        } _unused;
-    } _new;
-
-# ifndef _REENT_GLOBAL_ATEXIT
-  /* atexit stuff */
-  struct _atexit *_atexit;	/* points to head of LIFO stack */
-  struct _atexit _atexit0;	/* one guaranteed table, required by ANSI */
-# endif
-
-  /* signal info */
-  void (**(_sig_func))(int);
-
-  /* These are here last so that __FILE can grow without changing the offsets
-     of the above members (on the off chance that future binary compatibility
-     would be broken otherwise).  */
-  struct _glue __sglue;		/* root of glue chain */
-# ifndef _REENT_GLOBAL_STDIO_STREAMS
-  __FILE __sf[3];  		/* first three file descriptors */
-# endif
-};
-
-#ifdef _REENT_GLOBAL_STDIO_STREAMS
-extern __FILE __sf[3];
-#define _REENT_STDIO_STREAM(var, index) &__sf[index]
-#else
-#define _REENT_STDIO_STREAM(var, index) &(var)->__sf[index]
-#endif
-
-#define _REENT_INIT(var) \
-  { 0, \
-    _REENT_STDIO_STREAM(&(var), 0), \
-    _REENT_STDIO_STREAM(&(var), 1), \
-    _REENT_STDIO_STREAM(&(var), 2), \
-    0, \
-    "", \
-    0, \
-    _NULL, \
-    0, \
-    _NULL, \
-    _NULL, \
-    0, \
-    _NULL, \
-    _NULL, \
-    0, \
-    _NULL, \
-    { \
-      { \
-        0, \
-        _NULL, \
-        "", \
-        {0, 0, 0, 0, 0, 0, 0, 0, 0}, \
-        0, \
-        1, \
-        { \
-          {_RAND48_SEED_0, _RAND48_SEED_1, _RAND48_SEED_2}, \
-          {_RAND48_MULT_0, _RAND48_MULT_1, _RAND48_MULT_2}, \
-          _RAND48_ADD \
-        }, \
-        {0, {0}}, \
-        {0, {0}}, \
-        {0, {0}}, \
-        "", \
-        "", \
-        0, \
-        {0, {0}}, \
-        {0, {0}}, \
-        {0, {0}}, \
-        {0, {0}}, \
-        {0, {0}} \
-      } \
-    }, \
-    _REENT_INIT_ATEXIT \
-    _NULL, \
-    {_NULL, 0, _NULL} \
-  }
-
-#define _REENT_INIT_PTR_ZEROED(var) \
-  { (var)->_stdin = _REENT_STDIO_STREAM(var, 0); \
-    (var)->_stdout = _REENT_STDIO_STREAM(var, 1); \
-    (var)->_stderr = _REENT_STDIO_STREAM(var, 2); \
-    (var)->_new._reent._rand_next = 1; \
-    (var)->_new._reent._r48._seed[0] = _RAND48_SEED_0; \
-    (var)->_new._reent._r48._seed[1] = _RAND48_SEED_1; \
-    (var)->_new._reent._r48._seed[2] = _RAND48_SEED_2; \
-    (var)->_new._reent._r48._mult[0] = _RAND48_MULT_0; \
-    (var)->_new._reent._r48._mult[1] = _RAND48_MULT_1; \
-    (var)->_new._reent._r48._mult[2] = _RAND48_MULT_2; \
-    (var)->_new._reent._r48._add = _RAND48_ADD; \
-  }
-
-#define _REENT_CHECK_RAND48(ptr)	/* nothing */
-#define _REENT_CHECK_MP(ptr)		/* nothing */
-#define _REENT_CHECK_TM(ptr)		/* nothing */
-#define _REENT_CHECK_ASCTIME_BUF(ptr)	/* nothing */
-#define _REENT_CHECK_EMERGENCY(ptr)	/* nothing */
-#define _REENT_CHECK_MISC(ptr)	        /* nothing */
-#define _REENT_CHECK_SIGNAL_BUF(ptr)	/* nothing */
-
-#define _REENT_SIGNGAM(ptr)	((ptr)->_new._reent._gamma_signgam)
-#define _REENT_RAND_NEXT(ptr)	((ptr)->_new._reent._rand_next)
-#define _REENT_RAND48_SEED(ptr)	((ptr)->_new._reent._r48._seed)
-#define _REENT_RAND48_MULT(ptr)	((ptr)->_new._reent._r48._mult)
-#define _REENT_RAND48_ADD(ptr)	((ptr)->_new._reent._r48._add)
-#define _REENT_MP_RESULT(ptr)	((ptr)->_result)
-#define _REENT_MP_RESULT_K(ptr)	((ptr)->_result_k)
-#define _REENT_MP_P5S(ptr)	((ptr)->_p5s)
-#define _REENT_MP_FREELIST(ptr)	((ptr)->_freelist)
-#define _REENT_ASCTIME_BUF(ptr)	((ptr)->_new._reent._asctime_buf)
-#define _REENT_TM(ptr)		(&(ptr)->_new._reent._localtime_buf)
-#define _REENT_EMERGENCY(ptr)	((ptr)->_emergency)
-#define _REENT_STRTOK_LAST(ptr)	((ptr)->_new._reent._strtok_last)
-#define _REENT_MBLEN_STATE(ptr)	((ptr)->_new._reent._mblen_state)
-#define _REENT_MBTOWC_STATE(ptr)((ptr)->_new._reent._mbtowc_state)
-#define _REENT_WCTOMB_STATE(ptr)((ptr)->_new._reent._wctomb_state)
-#define _REENT_MBRLEN_STATE(ptr)((ptr)->_new._reent._mbrlen_state)
-#define _REENT_MBRTOWC_STATE(ptr)((ptr)->_new._reent._mbrtowc_state)
-#define _REENT_MBSRTOWCS_STATE(ptr)((ptr)->_new._reent._mbsrtowcs_state)
-#define _REENT_WCRTOMB_STATE(ptr)((ptr)->_new._reent._wcrtomb_state)
-#define _REENT_WCSRTOMBS_STATE(ptr)((ptr)->_new._reent._wcsrtombs_state)
-#define _REENT_L64A_BUF(ptr)    ((ptr)->_new._reent._l64a_buf)
-#define _REENT_SIGNAL_BUF(ptr)  ((ptr)->_new._reent._signal_buf)
-#define _REENT_GETDATE_ERR_P(ptr) (&((ptr)->_new._reent._getdate_err))
-
-#endif /* !_REENT_SMALL */
-
-#define _REENT_INIT_PTR(var) \
-  { memset((var), 0, sizeof(*(var))); \
-    _REENT_INIT_PTR_ZEROED(var); \
-  }
-
-/* This value is used in stdlib/misc.c.  reent/reent.c has to know it
-   as well to make sure the freelist is correctly free'd.  Therefore
-   we define it here, rather than in stdlib/misc.c, as before. */
-#define _Kmax (sizeof (size_t) << 3)
-
-/*
- * All references to struct _reent are via this pointer.
- * Internally, newlib routines that need to reference it should use _REENT.
- */
-
-#ifndef __ATTRIBUTE_IMPURE_PTR__
-#define __ATTRIBUTE_IMPURE_PTR__
-#endif
-
-extern struct _reent *_impure_ptr __ATTRIBUTE_IMPURE_PTR__;
-extern struct _reent *const _global_impure_ptr __ATTRIBUTE_IMPURE_PTR__;
-
-void _reclaim_reent (struct _reent *);
-
-/* #define _REENT_ONLY define this to get only reentrant routines */
-
-#if defined(__DYNAMIC_REENT__) && !defined(__SINGLE_THREAD__)
-#ifndef __getreent
-  struct _reent * __getreent (void);
-#endif
-# define _REENT (__getreent())
-#else /* __SINGLE_THREAD__ || !__DYNAMIC_REENT__ */
-# define _REENT _impure_ptr
-#endif /* __SINGLE_THREAD__ || !__DYNAMIC_REENT__ */
-
-#define _GLOBAL_REENT _global_impure_ptr
-
-#ifdef _REENT_GLOBAL_ATEXIT
-extern struct _atexit *_global_atexit; /* points to head of LIFO stack */
-# define _GLOBAL_ATEXIT _global_atexit
-#else
-# define _GLOBAL_ATEXIT (_GLOBAL_REENT->_atexit)
-#endif
-
-#ifdef __cplusplus
-}
-#endif
-#endif /* _SYS_REENT_H_ */

src/include/sys/sched.h

@@ -1,69 +0,0 @@
-/*
- *  Written by Joel Sherrill <joel@OARcorp.com>.
- *
- *  COPYRIGHT (c) 1989-2010.
- *  On-Line Applications Research Corporation (OAR).
- *
- *  Permission to use, copy, modify, and distribute this software for any
- *  purpose without fee is hereby granted, provided that this entire notice
- *  is included in all copies of any software which is or includes a copy
- *  or modification of this software.
- *
- *  THIS SOFTWARE IS BEING PROVIDED "AS IS", WITHOUT ANY EXPRESS OR IMPLIED
- *  WARRANTY.  IN PARTICULAR,  THE AUTHOR MAKES NO REPRESENTATION
- *  OR WARRANTY OF ANY KIND CONCERNING THE MERCHANTABILITY OF THIS
- *  SOFTWARE OR ITS FITNESS FOR ANY PARTICULAR PURPOSE.
- *
- *  $Id$
- */
-
-
-#ifndef _SYS_SCHED_H_
-#define _SYS_SCHED_H_
-
-#include <sys/_timespec.h>
-
-#ifdef __cplusplus
-extern "C" {
-#endif
-
-/* Scheduling Policies */
-/* Open Group Specifications Issue 6 */
-#if defined(__CYGWIN__)
-#define SCHED_OTHER    3
-#else
-#define SCHED_OTHER    0
-#endif
-
-#define SCHED_FIFO     1
-#define SCHED_RR       2
-
-#if defined(_POSIX_SPORADIC_SERVER)
-#define SCHED_SPORADIC 4
-#endif
-
-/* Scheduling Parameters */
-/* Open Group Specifications Issue 6 */
-
-struct sched_param {
-  int sched_priority;           /* Process execution scheduling priority */
-
-#if defined(_POSIX_SPORADIC_SERVER) || defined(_POSIX_THREAD_SPORADIC_SERVER)
-  int sched_ss_low_priority;    /* Low scheduling priority for sporadic */
-                                /*   server */
-  struct timespec sched_ss_repl_period;
-                                /* Replenishment period for sporadic server */
-  struct timespec sched_ss_init_budget;
-                               /* Initial budget for sporadic server */
-  int sched_ss_max_repl;       /* Maximum pending replenishments for */
-                               /* sporadic server */
-#endif
-};
-
-#ifdef __cplusplus
-}
-#endif
-
-#endif
-/* end of include file */
-

src/include/sys/select.h

@@ -1,76 +0,0 @@
-#ifndef _SYS_SELECT_H
-#define _SYS_SELECT_H
-
-/* We don't define fd_set and friends if we are compiling POSIX
-   source, or if we have included (or may include as indicated
-   by __USE_W32_SOCKETS) the W32api winsock[2].h header which
-   defines Windows versions of them.   Note that a program which
-   includes the W32api winsock[2].h header must know what it is doing;
-   it must not call the Cygwin select function.
-*/
-# if !(defined (_WINSOCK_H) || defined (_WINSOCKAPI_) || defined (__USE_W32_SOCKETS))
-
-#include <sys/cdefs.h>
-#include <sys/_sigset.h>
-#include <sys/_timeval.h>
-#include <sys/timespec.h>
-
-#if !defined(_SIGSET_T_DECLARED)
-#define	_SIGSET_T_DECLARED
-typedef	__sigset_t	sigset_t;
-#endif
-
-#  define _SYS_TYPES_FD_SET
-/*
- * Select uses bit masks of file descriptors in longs.
- * These macros manipulate such bit fields (the filesystem macros use chars).
- * FD_SETSIZE may be defined by the user, but the default here
- * should be >= NOFILE (param.h).
- */
-#  ifndef	FD_SETSIZE
-#	define	FD_SETSIZE	64
-#  endif
-
-typedef	unsigned long	fd_mask;
-#  define	NFDBITS	(sizeof (fd_mask) * 8)	/* bits per mask */
-#  ifndef	_howmany
-#	define	_howmany(x,y)	(((x)+((y)-1))/(y))
-#  endif
-
-/* We use a macro for fd_set so that including Sockets.h afterwards
-   can work.  */
-typedef	struct _types_fd_set {
-	fd_mask	fds_bits[_howmany(FD_SETSIZE, NFDBITS)];
-} _types_fd_set;
-
-#define fd_set _types_fd_set
-
-#  define	FD_SET(n, p)	((p)->fds_bits[(n)/NFDBITS] |= (1L << ((n) % NFDBITS)))
-#  define	FD_CLR(n, p)	((p)->fds_bits[(n)/NFDBITS] &= ~(1L << ((n) % NFDBITS)))
-#  define	FD_ISSET(n, p)	((p)->fds_bits[(n)/NFDBITS] & (1L << ((n) % NFDBITS)))
-#  define	FD_ZERO(p)	(__extension__ (void)({ \
-     size_t __i; \
-     char *__tmp = (char *)p; \
-     for (__i = 0; __i < sizeof (*(p)); ++__i) \
-       *__tmp++ = 0; \
-}))
-
-#if !defined (__INSIDE_CYGWIN_NET__)
-
-__BEGIN_DECLS
-
-int select __P ((int __n, fd_set *__readfds, fd_set *__writefds,
-		 fd_set *__exceptfds, struct timeval *__timeout));
-#if __POSIX_VISIBLE >= 200112
-int pselect __P ((int __n, fd_set *__readfds, fd_set *__writefds,
-		  fd_set *__exceptfds, const struct timespec *__timeout,
-		  const sigset_t *__set));
-#endif
-
-__END_DECLS
-
-#endif /* !__INSIDE_CYGWIN_NET__ */
-
-#endif /* !(_WINSOCK_H || _WINSOCKAPI_ || __USE_W32_SOCKETS) */
-
-#endif /* sys/select.h */

src/include/sys/stdio.h

@@ -1,27 +0,0 @@
-#ifndef _NEWLIB_STDIO_H
-#define _NEWLIB_STDIO_H
-
-#include <sys/lock.h>
-#include <sys/reent.h>
-
-/* Internal locking macros, used to protect stdio functions.  In the
-   general case, expand to nothing. Use __SSTR flag in FILE _flags to
-   detect if FILE is private to sprintf/sscanf class of functions; if
-   set then do nothing as lock is not initialised. */
-#if !defined(_flockfile)
-#ifndef __SINGLE_THREAD__
-#  define _flockfile(fp) (((fp)->_flags & __SSTR) ? 0 : __lock_acquire_recursive((fp)->_lock))
-#else
-#  define _flockfile(fp)	((void) 0)
-#endif
-#endif
-
-#if !defined(_funlockfile)
-#ifndef __SINGLE_THREAD__
-#  define _funlockfile(fp) (((fp)->_flags & __SSTR) ? 0 : __lock_release_recursive((fp)->_lock))
-#else
-#  define _funlockfile(fp)	((void) 0)
-#endif
-#endif
-
-#endif /* _NEWLIB_STDIO_H */

src/include/sys/string.h

@@ -1,2 +0,0 @@
-/* This is a dummy <sys/string.h> used as a placeholder for
-   systems that need to have a special header file.  */

src/include/sys/timespec.h

@@ -1,63 +0,0 @@
-/*-
- * Copyright (c) 1982, 1986, 1993
- *	The Regents of the University of California.  All rights reserved.
- *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions
- * are met:
- * 1. Redistributions of source code must retain the above copyright
- *    notice, this list of conditions and the following disclaimer.
- * 2. Redistributions in binary form must reproduce the above copyright
- *    notice, this list of conditions and the following disclaimer in the
- *    documentation and/or other materials provided with the distribution.
- * 4. Neither the name of the University nor the names of its contributors
- *    may be used to endorse or promote products derived from this software
- *    without specific prior written permission.
- *
- * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
- * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
- * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
- * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
- * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
- * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
- * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
- * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
- * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
- * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
- * SUCH DAMAGE.
- *
- *	@(#)time.h	8.5 (Berkeley) 5/4/95
- * from: FreeBSD: src/sys/sys/time.h,v 1.43 2000/03/20 14:09:05 phk Exp
- *	$FreeBSD$
- */
-
-#ifndef _SYS_TIMESPEC_H_
-#define _SYS_TIMESPEC_H_
-
-#include <sys/cdefs.h>
-#include <sys/_timespec.h>
-
-#if __BSD_VISIBLE
-#define	TIMEVAL_TO_TIMESPEC(tv, ts)					\
-	do {								\
-		(ts)->tv_sec = (tv)->tv_sec;				\
-		(ts)->tv_nsec = (tv)->tv_usec * 1000;			\
-	} while (0)
-#define	TIMESPEC_TO_TIMEVAL(tv, ts)					\
-	do {								\
-		(tv)->tv_sec = (ts)->tv_sec;				\
-		(tv)->tv_usec = (ts)->tv_nsec / 1000;			\
-	} while (0)
-
-#endif /* __BSD_VISIBLE */
-
-/*
- * Structure defined by POSIX.1b to be like a itimerval, but with
- * timespecs. Used in the timer_*() system calls.
- */
-struct itimerspec {
-	struct timespec  it_interval;
-	struct timespec  it_value;
-};
-
-#endif /* _SYS_TIMESPEC_H_ */

src/include/sys/types.h

@@ -1,246 +0,0 @@
-/* unified sys/types.h: 
-   start with sef's sysvi386 version.
-   merge go32 version -- a few ifdefs.
-   h8300hms, h8300xray, and sysvnecv70 disagree on the following types:
-
-   typedef int gid_t;
-   typedef int uid_t;
-   typedef int dev_t;
-   typedef int ino_t;
-   typedef int mode_t;
-   typedef int caddr_t;
-
-   however, these aren't "reasonable" values, the sysvi386 ones make far 
-   more sense, and should work sufficiently well (in particular, h8300 
-   doesn't have a stat, and the necv70 doesn't matter.) -- eichin
- */
-
-#ifndef _SYS_TYPES_H
-
-#include <_ansi.h>
-#include <sys/cdefs.h>
-#include <machine/_types.h>
-
-/* BSD types permitted by POSIX and always exposed as in Glibc.  Only provided
-   for backward compatibility with BSD code.  The uintN_t standard types should
-   be preferred in new code. */
-#if ___int8_t_defined
-typedef __uint8_t	u_int8_t;
-#endif
-#if ___int16_t_defined
-typedef __uint16_t	u_int16_t;
-#endif 
-#if ___int32_t_defined
-typedef __uint32_t	u_int32_t;
-#endif
-#if ___int64_t_defined
-typedef __uint64_t	u_int64_t;
-#endif
-typedef int register_t;
-#define __BIT_TYPES_DEFINED__ 1
-
-#if defined(__rtems__) || defined(__XMK__)
-/*
- *  The following section is RTEMS specific and is needed to more
- *  closely match the types defined in the BSD sys/types.h.
- *  This is needed to let the RTEMS/BSD TCP/IP stack compile.
- */
-
-/* deprecated */
-#if ___int64_t_defined
-typedef	__uint64_t	u_quad_t;
-typedef	__int64_t	quad_t;
-typedef	quad_t *	qaddr_t;
-#endif
-
-#endif /* __rtems__ || __XMK__ */
-
-#ifndef __need_inttypes
-
-#define _SYS_TYPES_H
-/* <stddef.h> must be before <sys/_types.h> for __size_t considerations */
-#include <stddef.h>
-#include <sys/_types.h>
-#include <sys/_stdint.h>
-
-#if __BSD_VISIBLE
-#include <machine/endian.h>
-#include <sys/select.h>
-#  define	physadr		physadr_t
-#  define	quad		quad_t
-
-#ifndef _IN_ADDR_T_DECLARED
-typedef	__uint32_t	in_addr_t;	/* base type for internet address */
-#define	_IN_ADDR_T_DECLARED
-#endif
-
-#ifndef _IN_PORT_T_DECLARED
-typedef	__uint16_t	in_port_t;
-#define	_IN_PORT_T_DECLARED
-#endif
-#endif /* __BSD_VISIBLE */
-
-#if __MISC_VISIBLE
-#ifndef _BSDTYPES_DEFINED
-/* also defined in mingw/gmon.h and in w32api/winsock[2].h */
-#ifndef __u_char_defined
-typedef	unsigned char	u_char;
-#define __u_char_defined
-#endif
-#ifndef __u_short_defined
-typedef	unsigned short	u_short;
-#define __u_short_defined
-#endif
-#ifndef __u_int_defined
-typedef	unsigned int	u_int;
-#define __u_int_defined
-#endif
-#ifndef __u_long_defined
-typedef	unsigned long	u_long;
-#define __u_long_defined
-#endif
-#define _BSDTYPES_DEFINED
-#endif
-#endif	/*__BSD_VISIBLE || __CYGWIN__ */
-
-#if __MISC_VISIBLE
-typedef	unsigned short	ushort;		/* System V compatibility */
-typedef	unsigned int	uint;		/* System V compatibility */
-typedef	unsigned long	ulong;		/* System V compatibility */
-#endif
-
-#ifndef _BLKCNT_T_DECLARED
-typedef	__blkcnt_t	blkcnt_t;
-#define	_BLKCNT_T_DECLARED
-#endif
-
-#ifndef _BLKSIZE_T_DECLARED
-typedef	__blksize_t	blksize_t;
-#define	_BLKSIZE_T_DECLARED
-#endif
-
-#if !defined(__clock_t_defined) && !defined(_CLOCK_T_DECLARED)
-typedef	_CLOCK_T_	clock_t;
-#define	__clock_t_defined
-#define	_CLOCK_T_DECLARED
-#endif
-
-#if !defined(__time_t_defined) && !defined(_TIME_T_DECLARED)
-typedef	_TIME_T_	time_t;
-#define	__time_t_defined
-#define	_TIME_T_DECLARED
-#endif
-
-#ifndef __daddr_t_defined
-typedef	long	daddr_t;
-#define __daddr_t_defined
-#endif
-#ifndef __caddr_t_defined
-typedef	char *	caddr_t;
-#define __caddr_t_defined
-#endif
-
-#ifndef _FSBLKCNT_T_DECLARED		/* for statvfs() */
-typedef	__fsblkcnt_t	fsblkcnt_t;
-typedef	__fsfilcnt_t	fsfilcnt_t;
-#define	_FSBLKCNT_T_DECLARED
-#endif
-
-#ifndef _ID_T_DECLARED
-typedef	__id_t		id_t;		/* can hold a uid_t or pid_t */
-#define	_ID_T_DECLARED
-#endif
-
-#ifndef _INO_T_DECLARED
-typedef	__ino_t		ino_t;		/* inode number */
-#define	_INO_T_DECLARED
-#endif
-
-#if defined(__i386__) && (defined(GO32) || defined(__MSDOS__))
-typedef	char *		addr_t;
-typedef unsigned long vm_offset_t;
-typedef unsigned long vm_size_t;
-#endif /* __i386__ && (GO32 || __MSDOS__) */
-
-/*
- * All these should be machine specific - right now they are all broken.
- * However, for all of Cygnus' embedded targets, we want them to all be
- * the same.  Otherwise things like sizeof (struct stat) might depend on
- * how the file was compiled (e.g. -mint16 vs -mint32, etc.).
- */
-
-#ifndef _OFF_T_DECLARED
-typedef	__off_t		off_t;		/* file offset */
-#define	_OFF_T_DECLARED
-#endif
-#ifndef _DEV_T_DECLARED
-typedef	__dev_t		dev_t;		/* device number or struct cdev */
-#define	_DEV_T_DECLARED
-#endif
-#ifndef _UID_T_DECLARED
-typedef	__uid_t		uid_t;		/* user id */
-#define	_UID_T_DECLARED
-#endif
-#ifndef _GID_T_DECLARED
-typedef	__gid_t		gid_t;		/* group id */
-#define	_GID_T_DECLARED
-#endif
-
-#ifndef _PID_T_DECLARED
-typedef	__pid_t		pid_t;		/* process id */
-#define	_PID_T_DECLARED
-#endif
-
-#ifndef _KEY_T_DECLARED
-typedef	__key_t		key_t;		/* IPC key */
-#define	_KEY_T_DECLARED
-#endif
-
-#ifndef _SSIZE_T_DECLARED
-typedef _ssize_t ssize_t;
-#define	_SSIZE_T_DECLARED
-#endif
-
-#ifndef _MODE_T_DECLARED
-typedef	__mode_t	mode_t;		/* permissions */
-#define	_MODE_T_DECLARED
-#endif
-
-#ifndef _NLINK_T_DECLARED
-typedef	__nlink_t	nlink_t;	/* link count */
-#define	_NLINK_T_DECLARED
-#endif
-
-#if !defined(__clockid_t_defined) && !defined(_CLOCKID_T_DECLARED)
-typedef	__clockid_t	clockid_t;
-#define	__clockid_t_defined
-#define	_CLOCKID_T_DECLARED
-#endif
-
-#if !defined(__timer_t_defined) && !defined(_TIMER_T_DECLARED)
-typedef	__timer_t	timer_t;
-#define	__timer_t_defined
-#define	_TIMER_T_DECLARED
-#endif
-
-#ifndef _USECONDS_T_DECLARED
-typedef	__useconds_t	useconds_t;	/* microseconds (unsigned) */
-#define	_USECONDS_T_DECLARED
-#endif
-
-#ifndef _SUSECONDS_T_DECLARED
-typedef	__suseconds_t	suseconds_t;
-#define	_SUSECONDS_T_DECLARED
-#endif
-
-typedef	__int64_t	sbintime_t;
-
-#include <sys/features.h>
-#include <sys/_pthreadtypes.h>
-#include <machine/types.h>
-
-#endif  /* !__need_inttypes */
-
-#undef __need_inttypes
-
-#endif	/* _SYS_TYPES_H */

src/include/sys/unistd.h

@@ -1,599 +0,0 @@
-#ifndef _SYS_UNISTD_H
-#define _SYS_UNISTD_H
-
-#ifdef __cplusplus
-extern "C" {
-#endif
-
-#include <_ansi.h>
-#define __need_size_t
-#define __need_ptrdiff_t
-#include <sys/cdefs.h>
-#include <sys/types.h>
-#include <sys/_types.h>
-#include <stddef.h>
-
-extern char **environ;
-
-void	_exit (int __status) _ATTRIBUTE ((__noreturn__));
-
-int	access (const char *__path, int __amode);
-unsigned  alarm (unsigned __secs);
-int     chdir (const char *__path);
-int     chmod (const char *__path, mode_t __mode);
-#if !defined(__INSIDE_CYGWIN__)
-int     chown (const char *__path, uid_t __owner, gid_t __group);
-#endif
-#if __BSD_VISIBLE || (__XSI_VISIBLE >= 4 && __POSIX_VISIBLE < 200112)
-int     chroot (const char *__path);
-#endif
-int     close (int __fildes);
-#if __POSIX_VISIBLE >= 199209
-size_t	confstr (int __name, char *__buf, size_t __len);
-#endif
-#if __XSI_VISIBLE
-char *  crypt (const char *__key, const char *__salt);
-#endif
-#if __XSI_VISIBLE && __XSI_VISIBLE < 700
-char *  ctermid (char *__s);
-#endif
-#if __XSI_VISIBLE && __XSI_VISIBLE < 600
-char *  cuserid (char *__s);
-#endif
-#if __BSD_VISIBLE || (__XSI_VISIBLE && __XSI_VISIBLE < 500)
-int	daemon (int nochdir, int noclose);
-#endif
-int     dup (int __fildes);
-int     dup2 (int __fildes, int __fildes2);
-#if __GNU_VISIBLE
-int     dup3 (int __fildes, int __fildes2, int flags);
-int	eaccess (const char *__path, int __mode);
-#endif
-#if __XSI_VISIBLE
-void	encrypt (char *__block, int __edflag);
-#endif
-#if __BSD_VISIBLE || (__XSI_VISIBLE && __XSI_VISIBLE < 500)
-void	endusershell (void);
-#endif
-#if __GNU_VISIBLE
-int	euidaccess (const char *__path, int __mode);
-#endif
-int     execl (const char *__path, const char *, ...);
-int     execle (const char *__path, const char *, ...);
-int     execlp (const char *__file, const char *, ...);
-#if __MISC_VISIBLE
-int     execlpe (const char *__file, const char *, ...);
-#endif
-int     execv (const char *__path, char * const __argv[]);
-int     execve (const char *__path, char * const __argv[], char * const __envp[]);
-int     execvp (const char *__file, char * const __argv[]);
-#if __GNU_VISIBLE
-int     execvpe (const char *__file, char * const __argv[], char * const __envp[]);
-#endif
-#if __ATFILE_VISIBLE
-int	faccessat (int __dirfd, const char *__path, int __mode, int __flags);
-#endif
-#if __BSD_VISIBLE || __XSI_VISIBLE >= 4 || __POSIX_VISIBLE >= 200809
-int     fchdir (int __fildes);
-#endif
-#if __POSIX_VISIBLE >= 199309
-int     fchmod (int __fildes, mode_t __mode);
-#endif
-#if !defined(__INSIDE_CYGWIN__)
-#if __BSD_VISIBLE || __XSI_VISIBLE >= 4 || __POSIX_VISIBLE >= 200809
-int     fchown (int __fildes, uid_t __owner, gid_t __group);
-#endif
-#endif
-#if __ATFILE_VISIBLE
-int	fchownat (int __dirfd, const char *__path, uid_t __owner, gid_t __group, int __flags);
-#endif
-#if __POSIX_VISIBLE >= 200809
-int	fexecve (int __fd, char * const __argv[], char * const __envp[]);
-#endif
-pid_t   fork (void);
-long    fpathconf (int __fd, int __name);
-int     fsync (int __fd);
-#if __POSIX_VISIBLE >= 199309
-int     fdatasync (int __fd);
-#endif
-#if __GNU_VISIBLE
-char *  get_current_dir_name (void);
-#endif
-char *  getcwd (char *__buf, size_t __size);
-#if __BSD_VISIBLE || (__XSI_VISIBLE && __XSI_VISIBLE < 500)
-int	getdomainname  (char *__name, size_t __len);
-#endif
-#if __BSD_VISIBLE
-int     getentropy (void *, size_t);
-#endif
-#if !defined(__INSIDE_CYGWIN__)
-gid_t   getegid (void);
-uid_t   geteuid (void);
-gid_t   getgid (void);
-#endif
-int     getgroups (int __gidsetsize, gid_t __grouplist[]);
-#if __BSD_VISIBLE || __XSI_VISIBLE >= 4
-long    gethostid (void);
-#endif
-char *  getlogin (void);
-#if defined(_POSIX_THREAD_SAFE_FUNCTIONS)
-int getlogin_r (char *name, size_t namesize) ;
-#endif
-#if __BSD_VISIBLE || (__XSI_VISIBLE && __POSIX_VISIBLE < 200112)
-char *  getpass (const char *__prompt);
-int	getpagesize (void);
-#endif
-#if __BSD_VISIBLE
-int    getpeereid (int, uid_t *, gid_t *);
-#endif
-#if __POSIX_VISIBLE >= 200809 || __XSI_VISIBLE >= 4
-pid_t   getpgid (pid_t);
-#endif
-pid_t   getpgrp (void);
-pid_t   getpid (void);
-pid_t   getppid (void);
-#if __POSIX_VISIBLE >= 200809 || __XSI_VISIBLE >= 4
-pid_t   getsid (pid_t);
-#endif
-#if !defined(__INSIDE_CYGWIN__)
-uid_t   getuid (void);
-#endif
-#if __BSD_VISIBLE || (__XSI_VISIBLE && __XSI_VISIBLE < 500)
-char *	getusershell (void);
-#endif
-#if __BSD_VISIBLE || (__XSI_VISIBLE >= 4 && __POSIX_VISIBLE < 200809)
-char *  getwd (char *__buf);
-#endif
-#if __BSD_VISIBLE
-int	iruserok (unsigned long raddr, int superuser, const char *ruser, const char *luser);
-#endif
-int     isatty (int __fildes);
-#if __BSD_VISIBLE
-int        issetugid (void);
-#endif
-#if !defined(__INSIDE_CYGWIN__)
-#if __BSD_VISIBLE || __XSI_VISIBLE >= 4 || __POSIX_VISIBLE >= 200809
-int     lchown (const char *__path, uid_t __owner, gid_t __group);
-#endif
-#endif
-int     link (const char *__path1, const char *__path2);
-#if __ATFILE_VISIBLE
-int     linkat (int __dirfd1, const char *__path1, int __dirfd2, const char *__path2, int __flags);
-#endif
-#if __MISC_VISIBLE || __XSI_VISIBLE
-int	nice (int __nice_value);
-#endif
-#if !defined(__INSIDE_CYGWIN__)
-off_t   lseek (int __fildes, off_t __offset, int __whence);
-#endif
-#if __MISC_VISIBLE || __XSI_VISIBLE >= 4
-#define F_ULOCK	0
-#define F_LOCK	1
-#define F_TLOCK	2
-#define F_TEST	3
-int     lockf (int __fd, int __cmd, off_t __len);
-#endif
-long    pathconf (const char *__path, int __name);
-int     pause (void);
-#if __POSIX_VISIBLE >= 199506
-int	pthread_atfork (void (*)(void), void (*)(void), void (*)(void));
-#endif
-int     pipe (int __fildes[2]);
-#if __GNU_VISIBLE
-int     pipe2 (int __fildes[2], int flags);
-#endif
-#if __POSIX_VISIBLE >= 200809 || __XSI_VISIBLE >= 500
-ssize_t pread (int __fd, void *__buf, size_t __nbytes, off_t __offset);
-ssize_t pwrite (int __fd, const void *__buf, size_t __nbytes, off_t __offset);
-#endif
-_READ_WRITE_RETURN_TYPE read (int __fd, void *__buf, size_t __nbyte);
-#if __BSD_VISIBLE
-int	rresvport (int *__alport);
-int	revoke (char *__path);
-#endif
-int     rmdir (const char *__path);
-#if __BSD_VISIBLE
-int	ruserok (const char *rhost, int superuser, const char *ruser, const char *luser);
-#endif
-#if __BSD_VISIBLE || (__XSI_VISIBLE >= 4 && __POSIX_VISIBLE < 200112)
-void *  sbrk (ptrdiff_t __incr);
-#endif
-#if !defined(__INSIDE_CYGWIN__)
-#if __BSD_VISIBLE || __POSIX_VISIBLE >= 200112
-int     setegid (gid_t __gid);
-int     seteuid (uid_t __uid);
-#endif
-int     setgid (gid_t __gid);
-#endif
-#if __BSD_VISIBLE
-int	setgroups (int ngroups, const gid_t *grouplist);
-#endif
-#if __BSD_VISIBLE || (__XSI_VISIBLE && __XSI_VISIBLE < 500)
-int	sethostname (const char *, size_t);
-#endif
-int     setpgid (pid_t __pid, pid_t __pgid);
-#if __SVID_VISIBLE || __XSI_VISIBLE >= 500
-int     setpgrp (void);
-#endif
-#if (__BSD_VISIBLE || __XSI_VISIBLE >= 4) && !defined(__INSIDE_CYGWIN__)
-int	setregid (gid_t __rgid, gid_t __egid);
-int	setreuid (uid_t __ruid, uid_t __euid);
-#endif
-pid_t   setsid (void);
-#if !defined(__INSIDE_CYGWIN__)
-int     setuid (uid_t __uid);
-#endif
-#if __BSD_VISIBLE || (__XSI_VISIBLE && __XSI_VISIBLE < 500)
-void	setusershell (void);
-#endif
-unsigned sleep (unsigned int __seconds);
-#if __XSI_VISIBLE
-void    swab (const void *__restrict, void *__restrict, ssize_t);
-#endif
-long    sysconf (int __name);
-pid_t   tcgetpgrp (int __fildes);
-int     tcsetpgrp (int __fildes, pid_t __pgrp_id);
-char *  ttyname (int __fildes);
-int     ttyname_r (int, char *, size_t);
-int     unlink (const char *__path);
-#if __XSI_VISIBLE >= 500 && __POSIX_VISIBLE < 200809 || __BSD_VISIBLE
-int 	usleep (useconds_t __useconds);
-#endif
-#if __BSD_VISIBLE
-int     vhangup (void);
-#endif
-_READ_WRITE_RETURN_TYPE write (int __fd, const void *__buf, size_t __nbyte);
-
-#ifdef __CYGWIN__
-# define __UNISTD_GETOPT__
-# include <getopt.h>
-# undef __UNISTD_GETOPT__
-#else
-extern char *optarg;			/* getopt(3) external variables */
-extern int optind, opterr, optopt;
-int	 getopt(int, char * const [], const char *);
-extern int optreset;			/* getopt(3) external variable */
-#endif
-
-#if __BSD_VISIBLE || (__XSI_VISIBLE >= 4 && __POSIX_VISIBLE < 200809)
-pid_t   vfork (void);
-#endif
-
-#ifdef _COMPILING_NEWLIB
-/* Provide prototypes for most of the _<systemcall> names that are
-   provided in newlib for some compilers.  */
-int     _close (int __fildes);
-pid_t   _fork (void);
-pid_t   _getpid (void);
-int	_isatty (int __fildes);
-int     _link (const char *__path1, const char *__path2);
-_off_t   _lseek (int __fildes, _off_t __offset, int __whence);
-#ifdef __LARGE64_FILES
-_off64_t _lseek64 (int __filedes, _off64_t __offset, int __whence);
-#endif
-_READ_WRITE_RETURN_TYPE _read (int __fd, void *__buf, size_t __nbyte);
-void *  _sbrk (ptrdiff_t __incr);
-int     _unlink (const char *__path);
-_READ_WRITE_RETURN_TYPE _write (int __fd, const void *__buf, size_t __nbyte);
-int     _execve (const char *__path, char * const __argv[], char * const __envp[]);
-#endif
-
-#if !defined(__INSIDE_CYGWIN__)
-#if __POSIX_VISIBLE >= 200112 || __XSI_VISIBLE >= 500
-int     ftruncate (int __fd, off_t __length);
-#endif
-#if __POSIX_VISIBLE >= 200809 || __XSI_VISIBLE >= 500
-int     truncate (const char *, off_t __length);
-#endif
-#endif
-
-#if __BSD_VISIBLE || __POSIX_VISIBLE < 200112
-int	getdtablesize (void);
-#endif
-#if __BSD_VISIBLE || __POSIX_VISIBLE >= 200809 || __XSI_VISIBLE >= 500
-useconds_t ualarm (useconds_t __useconds, useconds_t __interval);
-#endif
-
-#if __BSD_VISIBLE || __POSIX_VISIBLE >= 200112 || __XSI_VISIBLE >= 500
-#if !(defined  (_WINSOCK_H) || defined (_WINSOCKAPI_) || defined (__USE_W32_SOCKETS))
-/* winsock[2].h defines as __stdcall, and with int as 2nd arg */
- int	gethostname (char *__name, size_t __len);
-#endif
-#endif
-
-#if __MISC_VISIBLE
-int	setdtablesize (int);
-#endif
-
-#if __BSD_VISIBLE || __XSI_VISIBLE >= 500
-void    sync (void);
-#endif
-
-#if __BSD_VISIBLE || __POSIX_VISIBLE >= 200112 || __XSI_VISIBLE >= 4
-ssize_t readlink (const char *__restrict __path,
-                          char *__restrict __buf, size_t __buflen);
-int     symlink (const char *__name1, const char *__name2);
-#endif
-#if __ATFILE_VISIBLE
-ssize_t        readlinkat (int __dirfd1, const char *__restrict __path,
-                            char *__restrict __buf, size_t __buflen);
-int	symlinkat (const char *, int, const char *);
-int	unlinkat (int, const char *, int);
-#endif
-
-#define	F_OK	0
-#define	R_OK	4
-#define	W_OK	2
-#define	X_OK	1
-
-# define	SEEK_SET	0
-# define	SEEK_CUR	1
-# define	SEEK_END	2
-
-#include <sys/features.h>
-
-#define STDIN_FILENO    0       /* standard input file descriptor */
-#define STDOUT_FILENO   1       /* standard output file descriptor */
-#define STDERR_FILENO   2       /* standard error file descriptor */
-
-/*
- *  sysconf values per IEEE Std 1003.1, 2008 Edition
- */
-
-#define _SC_ARG_MAX                       0
-#define _SC_CHILD_MAX                     1
-#define _SC_CLK_TCK                       2
-#define _SC_NGROUPS_MAX                   3
-#define _SC_OPEN_MAX                      4
-#define _SC_JOB_CONTROL                   5
-#define _SC_SAVED_IDS                     6
-#define _SC_VERSION                       7
-#define _SC_PAGESIZE                      8
-#define _SC_PAGE_SIZE                     _SC_PAGESIZE
-/* These are non-POSIX values we accidentally introduced in 2000 without
-   guarding them.  Keeping them unguarded for backward compatibility. */
-#define _SC_NPROCESSORS_CONF              9
-#define _SC_NPROCESSORS_ONLN             10
-#define _SC_PHYS_PAGES                   11
-#define _SC_AVPHYS_PAGES                 12
-/* End of non-POSIX values. */
-#define _SC_MQ_OPEN_MAX                  13
-#define _SC_MQ_PRIO_MAX                  14
-#define _SC_RTSIG_MAX                    15
-#define _SC_SEM_NSEMS_MAX                16
-#define _SC_SEM_VALUE_MAX                17
-#define _SC_SIGQUEUE_MAX                 18
-#define _SC_TIMER_MAX                    19
-#define _SC_TZNAME_MAX                   20
-#define _SC_ASYNCHRONOUS_IO              21
-#define _SC_FSYNC                        22
-#define _SC_MAPPED_FILES                 23
-#define _SC_MEMLOCK                      24
-#define _SC_MEMLOCK_RANGE                25
-#define _SC_MEMORY_PROTECTION            26
-#define _SC_MESSAGE_PASSING              27
-#define _SC_PRIORITIZED_IO               28
-#define _SC_REALTIME_SIGNALS             29
-#define _SC_SEMAPHORES                   30
-#define _SC_SHARED_MEMORY_OBJECTS        31
-#define _SC_SYNCHRONIZED_IO              32
-#define _SC_TIMERS                       33
-#define _SC_AIO_LISTIO_MAX               34
-#define _SC_AIO_MAX                      35
-#define _SC_AIO_PRIO_DELTA_MAX           36
-#define _SC_DELAYTIMER_MAX               37
-#define _SC_THREAD_KEYS_MAX              38
-#define _SC_THREAD_STACK_MIN             39
-#define _SC_THREAD_THREADS_MAX           40
-#define _SC_TTY_NAME_MAX                 41
-#define _SC_THREADS                      42
-#define _SC_THREAD_ATTR_STACKADDR        43
-#define _SC_THREAD_ATTR_STACKSIZE        44
-#define _SC_THREAD_PRIORITY_SCHEDULING   45
-#define _SC_THREAD_PRIO_INHERIT          46
-/* _SC_THREAD_PRIO_PROTECT was _SC_THREAD_PRIO_CEILING in early drafts */
-#define _SC_THREAD_PRIO_PROTECT          47
-#define _SC_THREAD_PRIO_CEILING          _SC_THREAD_PRIO_PROTECT
-#define _SC_THREAD_PROCESS_SHARED        48
-#define _SC_THREAD_SAFE_FUNCTIONS        49
-#define _SC_GETGR_R_SIZE_MAX             50
-#define _SC_GETPW_R_SIZE_MAX             51
-#define _SC_LOGIN_NAME_MAX               52
-#define _SC_THREAD_DESTRUCTOR_ITERATIONS 53
-#define _SC_ADVISORY_INFO                54
-#define _SC_ATEXIT_MAX                   55
-#define _SC_BARRIERS                     56
-#define _SC_BC_BASE_MAX                  57
-#define _SC_BC_DIM_MAX                   58
-#define _SC_BC_SCALE_MAX                 59
-#define _SC_BC_STRING_MAX                60
-#define _SC_CLOCK_SELECTION              61
-#define _SC_COLL_WEIGHTS_MAX             62
-#define _SC_CPUTIME                      63
-#define _SC_EXPR_NEST_MAX                64
-#define _SC_HOST_NAME_MAX                65
-#define _SC_IOV_MAX                      66
-#define _SC_IPV6                         67
-#define _SC_LINE_MAX                     68
-#define _SC_MONOTONIC_CLOCK              69
-#define _SC_RAW_SOCKETS                  70
-#define _SC_READER_WRITER_LOCKS          71
-#define _SC_REGEXP                       72
-#define _SC_RE_DUP_MAX                   73
-#define _SC_SHELL                        74
-#define _SC_SPAWN                        75
-#define _SC_SPIN_LOCKS                   76
-#define _SC_SPORADIC_SERVER              77
-#define _SC_SS_REPL_MAX                  78
-#define _SC_SYMLOOP_MAX                  79
-#define _SC_THREAD_CPUTIME               80
-#define _SC_THREAD_SPORADIC_SERVER       81
-#define _SC_TIMEOUTS                     82
-#define _SC_TRACE                        83
-#define _SC_TRACE_EVENT_FILTER           84
-#define _SC_TRACE_EVENT_NAME_MAX         85
-#define _SC_TRACE_INHERIT                86
-#define _SC_TRACE_LOG                    87
-#define _SC_TRACE_NAME_MAX               88
-#define _SC_TRACE_SYS_MAX                89
-#define _SC_TRACE_USER_EVENT_MAX         90
-#define _SC_TYPED_MEMORY_OBJECTS         91
-#define _SC_V7_ILP32_OFF32               92
-#define _SC_V6_ILP32_OFF32               _SC_V7_ILP32_OFF32
-#define _SC_XBS5_ILP32_OFF32             _SC_V7_ILP32_OFF32
-#define _SC_V7_ILP32_OFFBIG              93
-#define _SC_V6_ILP32_OFFBIG              _SC_V7_ILP32_OFFBIG
-#define _SC_XBS5_ILP32_OFFBIG            _SC_V7_ILP32_OFFBIG
-#define _SC_V7_LP64_OFF64                94
-#define _SC_V6_LP64_OFF64                _SC_V7_LP64_OFF64
-#define _SC_XBS5_LP64_OFF64              _SC_V7_LP64_OFF64
-#define _SC_V7_LPBIG_OFFBIG              95
-#define _SC_V6_LPBIG_OFFBIG              _SC_V7_LPBIG_OFFBIG
-#define _SC_XBS5_LPBIG_OFFBIG            _SC_V7_LPBIG_OFFBIG
-#define _SC_XOPEN_CRYPT                  96
-#define _SC_XOPEN_ENH_I18N               97
-#define _SC_XOPEN_LEGACY                 98
-#define _SC_XOPEN_REALTIME               99
-#define _SC_STREAM_MAX                  100
-#define _SC_PRIORITY_SCHEDULING         101
-#define _SC_XOPEN_REALTIME_THREADS      102
-#define _SC_XOPEN_SHM                   103
-#define _SC_XOPEN_STREAMS               104
-#define _SC_XOPEN_UNIX                  105
-#define _SC_XOPEN_VERSION               106
-#define _SC_2_CHAR_TERM                 107
-#define _SC_2_C_BIND                    108
-#define _SC_2_C_DEV                     109
-#define _SC_2_FORT_DEV                  110
-#define _SC_2_FORT_RUN                  111
-#define _SC_2_LOCALEDEF                 112
-#define _SC_2_PBS                       113
-#define _SC_2_PBS_ACCOUNTING            114
-#define _SC_2_PBS_CHECKPOINT            115
-#define _SC_2_PBS_LOCATE                116
-#define _SC_2_PBS_MESSAGE               117
-#define _SC_2_PBS_TRACK                 118
-#define _SC_2_SW_DEV                    119
-#define _SC_2_UPE                       120
-#define _SC_2_VERSION                   121
-#define _SC_THREAD_ROBUST_PRIO_INHERIT  122
-#define _SC_THREAD_ROBUST_PRIO_PROTECT  123
-#define _SC_XOPEN_UUCP                  124
-#define _SC_LEVEL1_ICACHE_SIZE          125
-#define _SC_LEVEL1_ICACHE_ASSOC         126
-#define _SC_LEVEL1_ICACHE_LINESIZE      127
-#define _SC_LEVEL1_DCACHE_SIZE          128
-#define _SC_LEVEL1_DCACHE_ASSOC         129
-#define _SC_LEVEL1_DCACHE_LINESIZE      130
-#define _SC_LEVEL2_CACHE_SIZE           131
-#define _SC_LEVEL2_CACHE_ASSOC          132
-#define _SC_LEVEL2_CACHE_LINESIZE       133
-#define _SC_LEVEL3_CACHE_SIZE           134
-#define _SC_LEVEL3_CACHE_ASSOC          135
-#define _SC_LEVEL3_CACHE_LINESIZE       136
-#define _SC_LEVEL4_CACHE_SIZE           137
-#define _SC_LEVEL4_CACHE_ASSOC          138
-#define _SC_LEVEL4_CACHE_LINESIZE       139
-#define _SC_POSIX_26_VERSION            140
-
-/*
- *  pathconf values per IEEE Std 1003.1, 2008 Edition
- */
-
-#define _PC_LINK_MAX                      0
-#define _PC_MAX_CANON                     1
-#define _PC_MAX_INPUT                     2
-#define _PC_NAME_MAX                      3
-#define _PC_PATH_MAX                      4
-#define _PC_PIPE_BUF                      5
-#define _PC_CHOWN_RESTRICTED              6
-#define _PC_NO_TRUNC                      7
-#define _PC_VDISABLE                      8
-#define _PC_ASYNC_IO                      9
-#define _PC_PRIO_IO                      10
-#define _PC_SYNC_IO                      11
-#define _PC_FILESIZEBITS                 12
-#define _PC_2_SYMLINKS                   13
-#define _PC_SYMLINK_MAX                  14
-#define _PC_ALLOC_SIZE_MIN               15
-#define _PC_REC_INCR_XFER_SIZE           16
-#define _PC_REC_MAX_XFER_SIZE            17
-#define _PC_REC_MIN_XFER_SIZE            18
-#define _PC_REC_XFER_ALIGN               19
-#define _PC_TIMESTAMP_RESOLUTION         20
-#ifdef __CYGWIN__
-/* Ask for POSIX permission bits support. */
-#define _PC_POSIX_PERMISSIONS            90
-/* Ask for full POSIX permission support including uid/gid settings. */
-#define _PC_POSIX_SECURITY               91
-#define _PC_CASE_INSENSITIVE             92
-#endif
-
-/*
- *  confstr values per IEEE Std 1003.1, 2004 Edition
- */
-
-#ifdef __CYGWIN__	/* Only defined on Cygwin for now. */
-#define _CS_PATH                               0
-#define _CS_POSIX_V7_ILP32_OFF32_CFLAGS        1
-#define _CS_POSIX_V6_ILP32_OFF32_CFLAGS       _CS_POSIX_V7_ILP32_OFF32_CFLAGS
-#define _CS_XBS5_ILP32_OFF32_CFLAGS           _CS_POSIX_V7_ILP32_OFF32_CFLAGS
-#define _CS_POSIX_V7_ILP32_OFF32_LDFLAGS       2
-#define _CS_POSIX_V6_ILP32_OFF32_LDFLAGS      _CS_POSIX_V7_ILP32_OFF32_LDFLAGS
-#define _CS_XBS5_ILP32_OFF32_LDFLAGS          _CS_POSIX_V7_ILP32_OFF32_LDFLAGS
-#define _CS_POSIX_V7_ILP32_OFF32_LIBS          3
-#define _CS_POSIX_V6_ILP32_OFF32_LIBS         _CS_POSIX_V7_ILP32_OFF32_LIBS
-#define _CS_XBS5_ILP32_OFF32_LIBS             _CS_POSIX_V7_ILP32_OFF32_LIBS
-#define _CS_XBS5_ILP32_OFF32_LINTFLAGS         4
-#define _CS_POSIX_V7_ILP32_OFFBIG_CFLAGS       5
-#define _CS_POSIX_V6_ILP32_OFFBIG_CFLAGS      _CS_POSIX_V7_ILP32_OFFBIG_CFLAGS
-#define _CS_XBS5_ILP32_OFFBIG_CFLAGS          _CS_POSIX_V7_ILP32_OFFBIG_CFLAGS
-#define _CS_POSIX_V7_ILP32_OFFBIG_LDFLAGS      6
-#define _CS_POSIX_V6_ILP32_OFFBIG_LDFLAGS     _CS_POSIX_V7_ILP32_OFFBIG_LDFLAGS
-#define _CS_XBS5_ILP32_OFFBIG_LDFLAGS         _CS_POSIX_V7_ILP32_OFFBIG_LDFLAGS
-#define _CS_POSIX_V7_ILP32_OFFBIG_LIBS         7
-#define _CS_POSIX_V6_ILP32_OFFBIG_LIBS        _CS_POSIX_V7_ILP32_OFFBIG_LIBS
-#define _CS_XBS5_ILP32_OFFBIG_LIBS            _CS_POSIX_V7_ILP32_OFFBIG_LIBS
-#define _CS_XBS5_ILP32_OFFBIG_LINTFLAGS        8
-#define _CS_POSIX_V7_LP64_OFF64_CFLAGS         9
-#define _CS_POSIX_V6_LP64_OFF64_CFLAGS        _CS_POSIX_V7_LP64_OFF64_CFLAGS
-#define _CS_XBS5_LP64_OFF64_CFLAGS            _CS_POSIX_V7_LP64_OFF64_CFLAGS
-#define _CS_POSIX_V7_LP64_OFF64_LDFLAGS       10
-#define _CS_POSIX_V6_LP64_OFF64_LDFLAGS       _CS_POSIX_V7_LP64_OFF64_LDFLAGS
-#define _CS_XBS5_LP64_OFF64_LDFLAGS           _CS_POSIX_V7_LP64_OFF64_LDFLAGS
-#define _CS_POSIX_V7_LP64_OFF64_LIBS          11
-#define _CS_POSIX_V6_LP64_OFF64_LIBS          _CS_POSIX_V7_LP64_OFF64_LIBS
-#define _CS_XBS5_LP64_OFF64_LIBS              _CS_POSIX_V7_LP64_OFF64_LIBS
-#define _CS_XBS5_LP64_OFF64_LINTFLAGS         12
-#define _CS_POSIX_V7_LPBIG_OFFBIG_CFLAGS      13
-#define _CS_POSIX_V6_LPBIG_OFFBIG_CFLAGS      _CS_POSIX_V7_LPBIG_OFFBIG_CFLAGS
-#define _CS_XBS5_LPBIG_OFFBIG_CFLAGS          _CS_POSIX_V7_LPBIG_OFFBIG_CFLAGS
-#define _CS_POSIX_V7_LPBIG_OFFBIG_LDFLAGS     14
-#define _CS_POSIX_V6_LPBIG_OFFBIG_LDFLAGS     _CS_POSIX_V7_LPBIG_OFFBIG_LDFLAGS
-#define _CS_XBS5_LPBIG_OFFBIG_LDFLAGS         _CS_POSIX_V7_LPBIG_OFFBIG_LDFLAGS
-#define _CS_POSIX_V7_LPBIG_OFFBIG_LIBS        15
-#define _CS_POSIX_V6_LPBIG_OFFBIG_LIBS        _CS_POSIX_V7_LPBIG_OFFBIG_LIBS
-#define _CS_XBS5_LPBIG_OFFBIG_LIBS            _CS_POSIX_V7_LPBIG_OFFBIG_LIBS
-#define _CS_XBS5_LPBIG_OFFBIG_LINTFLAGS       16
-#define _CS_POSIX_V7_WIDTH_RESTRICTED_ENVS    17
-#define _CS_POSIX_V6_WIDTH_RESTRICTED_ENVS    _CS_POSIX_V7_WIDTH_RESTRICTED_ENVS
-#define _CS_XBS5_WIDTH_RESTRICTED_ENVS        _CS_POSIX_V7_WIDTH_RESTRICTED_ENVS
-#define _CS_POSIX_V7_THREADS_CFLAGS           18
-#define _CS_POSIX_V7_THREADS_LDFLAGS          19
-#define _CS_V7_ENV                            20
-#define _CS_V6_ENV                            _CS_V7_ENV
-#define _CS_LFS_CFLAGS                        21
-#define _CS_LFS_LDFLAGS                       22
-#define _CS_LFS_LIBS                          23
-#define _CS_LFS_LINTFLAGS                     24
-#endif
-
-#ifdef __cplusplus
-}
-#endif
-
-#if __SSP_FORTIFY_LEVEL > 0
-#include <ssp/unistd.h>
-#endif
-
-#endif /* _SYS_UNISTD_H */

src/include/unistd.h

@@ -1,6 +0,0 @@
-#ifndef _UNISTD_H_
-#define _UNISTD_H_
-
-# include <sys/unistd.h>
-
-#endif /* _UNISTD_H_ */

src/include/xlocale.h

@@ -1,12 +0,0 @@
-/* Definition of opaque POSIX-1.2008 type locale_t for userspace. */
-
-#ifndef	_XLOCALE_H
-#define _XLOCALE_H
-
-#include <newlib.h>
-#include <sys/config.h>
-
-struct __locale_t;
-typedef struct __locale_t *locale_t;
-
-#endif	/* _XLOCALE_H */

src/libc/Cargo.toml

@@ -1,12 +0,0 @@
-[package]
-name = "libc"
-version = "0.1.0"
-authors = ["M-Labs"]
-edition = "2018"
-build = "build.rs"
-
-[dependencies]
-libboard_zynq = { git = "https://git.m-labs.hk/M-Labs/zynq-rs.git" }
-
-[build-dependencies]
-cc = { version = "1.0.1" }

src/libc/build.rs

@@ -1,42 +0,0 @@
-fn main() {
-    println!("cargo:rerun-if-changed=build.rs");
-    libc::compile();
-}
-
-mod libc {
-    use std::path::Path;
-    pub fn compile() {
-        let cfg = &mut cc::Build::new();
-        cfg.no_default_flags(true);
-        cfg.compiler("clang");
-        cfg.cpp(false);
-        cfg.warnings(false);
-
-        cfg.flag("-nostdlib");
-        cfg.flag("-ffreestanding");
-        cfg.flag("-fno-PIC");
-        cfg.flag("-isystem../include");
-        cfg.flag("-fno-stack-protector");
-        cfg.flag("--target=armv7-none-eabihf");
-        cfg.flag("-O2");
-
-        cfg.flag("-std=c99");
-        cfg.flag("-fstrict-aliasing");
-        cfg.flag("-funwind-tables");
-        cfg.flag("-fvisibility=hidden");
-        cfg.flag("-U_FORTIFY_SOURCE");
-        cfg.define("_FORTIFY_SOURCE", Some("0"));
-
-        let sources = vec![
-            "printf.c"
-        ];
-
-        let root = Path::new("./");
-        for src in sources {
-            println!("cargo:rerun-if-changed={}", src);
-            cfg.file(root.join("src").join(src));
-        }
-
-        cfg.compile("printf");
-    }
-}

src/libc/src/lib.rs

@@ -1,17 +0,0 @@
-// Helper crate for dealing with c ffi
-#![allow(non_camel_case_types)]
-#![no_std]
-
-use libboard_zynq::stdio;
-
-pub type c_char = i8;
-pub type c_int = i32;
-pub type size_t = usize;
-pub type uintptr_t = usize;
-pub type c_void = core::ffi::c_void;
-
-#[no_mangle]
-extern "C" fn _putchar(byte: u8) {
-    let mut uart = stdio::get_uart();
-    uart.write_byte(byte);
-}

src/libc/src/printf.c

@@ -1,913 +0,0 @@
-///////////////////////////////////////////////////////////////////////////////
-// \author (c) Marco Paland (info@paland.com)
-//             2014-2019, PALANDesign Hannover, Germany
-//
-// \license The MIT License (MIT)
-//
-// Permission is hereby granted, free of charge, to any person obtaining a copy
-// of this software and associated documentation files (the "Software"), to deal
-// in the Software without restriction, including without limitation the rights
-// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-// copies of the Software, and to permit persons to whom the Software is
-// furnished to do so, subject to the following conditions:
-//
-// The above copyright notice and this permission notice shall be included in
-// all copies or substantial portions of the Software.
-//
-// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
-// THE SOFTWARE.
-//
-// \brief Tiny printf, sprintf and (v)snprintf implementation, optimized for speed on
-//        embedded systems with a very limited resources. These routines are thread
-//        safe and reentrant!
-//        Use this instead of the bloated standard/newlib printf cause these use
-//        malloc for printf (and may not be thread safe).
-//
-///////////////////////////////////////////////////////////////////////////////
-
-#include <stdbool.h>
-#include <stdint.h>
-#include <stdio.h>
-
-// define this globally (e.g. gcc -DPRINTF_INCLUDE_CONFIG_H ...) to include the
-// printf_config.h header file
-// default: undefined
-#ifdef PRINTF_INCLUDE_CONFIG_H
-#include "printf_config.h"
-#endif
-
-
-// 'ntoa' conversion buffer size, this must be big enough to hold one converted
-// numeric number including padded zeros (dynamically created on stack)
-// default: 32 byte
-#ifndef PRINTF_NTOA_BUFFER_SIZE
-#define PRINTF_NTOA_BUFFER_SIZE    32U
-#endif
-
-// 'ftoa' conversion buffer size, this must be big enough to hold one converted
-// float number including padded zeros (dynamically created on stack)
-// default: 32 byte
-#ifndef PRINTF_FTOA_BUFFER_SIZE
-#define PRINTF_FTOA_BUFFER_SIZE    32U
-#endif
-
-// support for the floating point type (%f)
-// default: activated
-#ifndef PRINTF_DISABLE_SUPPORT_FLOAT
-#define PRINTF_SUPPORT_FLOAT
-#endif
-
-// support for exponential floating point notation (%e/%g)
-// default: activated
-#ifndef PRINTF_DISABLE_SUPPORT_EXPONENTIAL
-#define PRINTF_SUPPORT_EXPONENTIAL
-#endif
-
-// define the default floating point precision
-// default: 6 digits
-#ifndef PRINTF_DEFAULT_FLOAT_PRECISION
-#define PRINTF_DEFAULT_FLOAT_PRECISION  6U
-#endif
-
-// define the largest float suitable to print with %f
-// default: 1e9
-#ifndef PRINTF_MAX_FLOAT
-#define PRINTF_MAX_FLOAT  1e9
-#endif
-
-// support for the long long types (%llu or %p)
-// default: activated
-#ifndef PRINTF_DISABLE_SUPPORT_LONG_LONG
-#define PRINTF_SUPPORT_LONG_LONG
-#endif
-
-// support for the ptrdiff_t type (%t)
-// ptrdiff_t is normally defined in <stddef.h> as long or long long type
-// default: activated
-#ifndef PRINTF_DISABLE_SUPPORT_PTRDIFF_T
-#define PRINTF_SUPPORT_PTRDIFF_T
-#endif
-
-///////////////////////////////////////////////////////////////////////////////
-
-// internal flag definitions
-#define FLAGS_ZEROPAD   (1U <<  0U)
-#define FLAGS_LEFT      (1U <<  1U)
-#define FLAGS_PLUS      (1U <<  2U)
-#define FLAGS_SPACE     (1U <<  3U)
-#define FLAGS_HASH      (1U <<  4U)
-#define FLAGS_UPPERCASE (1U <<  5U)
-#define FLAGS_CHAR      (1U <<  6U)
-#define FLAGS_SHORT     (1U <<  7U)
-#define FLAGS_LONG      (1U <<  8U)
-#define FLAGS_LONG_LONG (1U <<  9U)
-#define FLAGS_PRECISION (1U << 10U)
-#define FLAGS_ADAPT_EXP (1U << 11U)
-
-
-// import float.h for DBL_MAX
-#if defined(PRINTF_SUPPORT_FLOAT)
-#include <float.h>
-#endif
-
-
-// output function type
-typedef void (*out_fct_type)(char character, void* buffer, size_t idx, size_t maxlen);
-
-
-// wrapper (used as buffer) for output function type
-typedef struct {
-  void  (*fct)(char character, void* arg);
-  void* arg;
-} out_fct_wrap_type;
-
-
-// internal buffer output
-static inline void _out_buffer(char character, void* buffer, size_t idx, size_t maxlen)
-{
-  if (idx < maxlen) {
-    ((char*)buffer)[idx] = character;
-  }
-}
-
-
-// internal null output
-static inline void _out_null(char character, void* buffer, size_t idx, size_t maxlen)
-{
-  (void)character; (void)buffer; (void)idx; (void)maxlen;
-}
-
-
-// internal _putchar wrapper
-static inline void _out_char(char character, void* buffer, size_t idx, size_t maxlen)
-{
-  (void)buffer; (void)idx; (void)maxlen;
-  if (character) {
-    _putchar(character);
-  }
-}
-
-
-// internal output function wrapper
-static inline void _out_fct(char character, void* buffer, size_t idx, size_t maxlen)
-{
-  (void)idx; (void)maxlen;
-  if (character) {
-    // buffer is the output fct pointer
-    ((out_fct_wrap_type*)buffer)->fct(character, ((out_fct_wrap_type*)buffer)->arg);
-  }
-}
-
-
-// internal secure strlen
-// \return The length of the string (excluding the terminating 0) limited by 'maxsize'
-static inline unsigned int _strnlen_s(const char* str, size_t maxsize)
-{
-  const char* s;
-  for (s = str; *s && maxsize--; ++s);
-  return (unsigned int)(s - str);
-}
-
-
-// internal test if char is a digit (0-9)
-// \return true if char is a digit
-static inline bool _is_digit(char ch)
-{
-  return (ch >= '0') && (ch <= '9');
-}
-
-
-// internal ASCII string to unsigned int conversion
-static unsigned int _atoi(const char** str)
-{
-  unsigned int i = 0U;
-  while (_is_digit(**str)) {
-    i = i * 10U + (unsigned int)(*((*str)++) - '0');
-  }
-  return i;
-}
-
-
-// output the specified string in reverse, taking care of any zero-padding
-static size_t _out_rev(out_fct_type out, char* buffer, size_t idx, size_t maxlen, const char* buf, size_t len, unsigned int width, unsigned int flags)
-{
-  const size_t start_idx = idx;
-
-  // pad spaces up to given width
-  if (!(flags & FLAGS_LEFT) && !(flags & FLAGS_ZEROPAD)) {
-    for (size_t i = len; i < width; i++) {
-      out(' ', buffer, idx++, maxlen);
-    }
-  }
-
-  // reverse string
-  while (len) {
-    out(buf[--len], buffer, idx++, maxlen);
-  }
-
-  // append pad spaces up to given width
-  if (flags & FLAGS_LEFT) {
-    while (idx - start_idx < width) {
-      out(' ', buffer, idx++, maxlen);
-    }
-  }
-
-  return idx;
-}
-
-
-// internal itoa format
-static size_t _ntoa_format(out_fct_type out, char* buffer, size_t idx, size_t maxlen, char* buf, size_t len, bool negative, unsigned int base, unsigned int prec, unsigned int width, unsigned int flags)
-{
-  // pad leading zeros
-  if (!(flags & FLAGS_LEFT)) {
-    if (width && (flags & FLAGS_ZEROPAD) && (negative || (flags & (FLAGS_PLUS | FLAGS_SPACE)))) {
-      width--;
-    }
-    while ((len < prec) && (len < PRINTF_NTOA_BUFFER_SIZE)) {
-      buf[len++] = '0';
-    }
-    while ((flags & FLAGS_ZEROPAD) && (len < width) && (len < PRINTF_NTOA_BUFFER_SIZE)) {
-      buf[len++] = '0';
-    }
-  }
-
-  // handle hash
-  if (flags & FLAGS_HASH) {
-    if (!(flags & FLAGS_PRECISION) && len && ((len == prec) || (len == width))) {
-      len--;
-      if (len && (base == 16U)) {
-        len--;
-      }
-    }
-    if ((base == 16U) && !(flags & FLAGS_UPPERCASE) && (len < PRINTF_NTOA_BUFFER_SIZE)) {
-      buf[len++] = 'x';
-    }
-    else if ((base == 16U) && (flags & FLAGS_UPPERCASE) && (len < PRINTF_NTOA_BUFFER_SIZE)) {
-      buf[len++] = 'X';
-    }
-    else if ((base == 2U) && (len < PRINTF_NTOA_BUFFER_SIZE)) {
-      buf[len++] = 'b';
-    }
-    if (len < PRINTF_NTOA_BUFFER_SIZE) {
-      buf[len++] = '0';
-    }
-  }
-
-  if (len < PRINTF_NTOA_BUFFER_SIZE) {
-    if (negative) {
-      buf[len++] = '-';
-    }
-    else if (flags & FLAGS_PLUS) {
-      buf[len++] = '+';  // ignore the space if the '+' exists
-    }
-    else if (flags & FLAGS_SPACE) {
-      buf[len++] = ' ';
-    }
-  }
-
-  return _out_rev(out, buffer, idx, maxlen, buf, len, width, flags);
-}
-
-
-// internal itoa for 'long' type
-static size_t _ntoa_long(out_fct_type out, char* buffer, size_t idx, size_t maxlen, unsigned long value, bool negative, unsigned long base, unsigned int prec, unsigned int width, unsigned int flags)
-{
-  char buf[PRINTF_NTOA_BUFFER_SIZE];
-  size_t len = 0U;
-
-  // no hash for 0 values
-  if (!value) {
-    flags &= ~FLAGS_HASH;
-  }
-
-  // write if precision != 0 and value is != 0
-  if (!(flags & FLAGS_PRECISION) || value) {
-    do {
-      const char digit = (char)(value % base);
-      buf[len++] = digit < 10 ? '0' + digit : (flags & FLAGS_UPPERCASE ? 'A' : 'a') + digit - 10;
-      value /= base;
-    } while (value && (len < PRINTF_NTOA_BUFFER_SIZE));
-  }
-
-  return _ntoa_format(out, buffer, idx, maxlen, buf, len, negative, (unsigned int)base, prec, width, flags);
-}
-
-
-// internal itoa for 'long long' type
-#if defined(PRINTF_SUPPORT_LONG_LONG)
-static size_t _ntoa_long_long(out_fct_type out, char* buffer, size_t idx, size_t maxlen, unsigned long long value, bool negative, unsigned long long base, unsigned int prec, unsigned int width, unsigned int flags)
-{
-  char buf[PRINTF_NTOA_BUFFER_SIZE];
-  size_t len = 0U;
-
-  // no hash for 0 values
-  if (!value) {
-    flags &= ~FLAGS_HASH;
-  }
-
-  // write if precision != 0 and value is != 0
-  if (!(flags & FLAGS_PRECISION) || value) {
-    do {
-      const char digit = (char)(value % base);
-      buf[len++] = digit < 10 ? '0' + digit : (flags & FLAGS_UPPERCASE ? 'A' : 'a') + digit - 10;
-      value /= base;
-    } while (value && (len < PRINTF_NTOA_BUFFER_SIZE));
-  }
-
-  return _ntoa_format(out, buffer, idx, maxlen, buf, len, negative, (unsigned int)base, prec, width, flags);
-}
-#endif  // PRINTF_SUPPORT_LONG_LONG
-
-
-#if defined(PRINTF_SUPPORT_FLOAT)
-
-#if defined(PRINTF_SUPPORT_EXPONENTIAL)
-// forward declaration so that _ftoa can switch to exp notation for values > PRINTF_MAX_FLOAT
-static size_t _etoa(out_fct_type out, char* buffer, size_t idx, size_t maxlen, double value, unsigned int prec, unsigned int width, unsigned int flags);
-#endif
-
-
-// internal ftoa for fixed decimal floating point
-static size_t _ftoa(out_fct_type out, char* buffer, size_t idx, size_t maxlen, double value, unsigned int prec, unsigned int width, unsigned int flags)
-{
-  char buf[PRINTF_FTOA_BUFFER_SIZE];
-  size_t len  = 0U;
-  double diff = 0.0;
-
-  // powers of 10
-  static const double pow10[] = { 1, 10, 100, 1000, 10000, 100000, 1000000, 10000000, 100000000, 1000000000 };
-
-  // test for special values
-  if (value != value)
-    return _out_rev(out, buffer, idx, maxlen, "nan", 3, width, flags);
-  if (value < -DBL_MAX)
-    return _out_rev(out, buffer, idx, maxlen, "fni-", 4, width, flags);
-  if (value > DBL_MAX)
-    return _out_rev(out, buffer, idx, maxlen, (flags & FLAGS_PLUS) ? "fni+" : "fni", (flags & FLAGS_PLUS) ? 4U : 3U, width, flags);
-
-  // test for very large values
-  // standard printf behavior is to print EVERY whole number digit -- which could be 100s of characters overflowing your buffers == bad
-  if ((value > PRINTF_MAX_FLOAT) || (value < -PRINTF_MAX_FLOAT)) {
-#if defined(PRINTF_SUPPORT_EXPONENTIAL)
-    return _etoa(out, buffer, idx, maxlen, value, prec, width, flags);
-#else
-    return 0U;
-#endif
-  }
-
-  // test for negative
-  bool negative = false;
-  if (value < 0) {
-    negative = true;
-    value = 0 - value;
-  }
-
-  // set default precision, if not set explicitly
-  if (!(flags & FLAGS_PRECISION)) {
-    prec = PRINTF_DEFAULT_FLOAT_PRECISION;
-  }
-  // limit precision to 9, cause a prec >= 10 can lead to overflow errors
-  while ((len < PRINTF_FTOA_BUFFER_SIZE) && (prec > 9U)) {
-    buf[len++] = '0';
-    prec--;
-  }
-
-  int whole = (int)value;
-  double tmp = (value - whole) * pow10[prec];
-  unsigned long frac = (unsigned long)tmp;
-  diff = tmp - frac;
-
-  if (diff > 0.5) {
-    ++frac;
-    // handle rollover, e.g. case 0.99 with prec 1 is 1.0
-    if (frac >= pow10[prec]) {
-      frac = 0;
-      ++whole;
-    }
-  }
-  else if (diff < 0.5) {
-  }
-  else if ((frac == 0U) || (frac & 1U)) {
-    // if halfway, round up if odd OR if last digit is 0
-    ++frac;
-  }
-
-  if (prec == 0U) {
-    diff = value - (double)whole;
-    if ((!(diff < 0.5) || (diff > 0.5)) && (whole & 1)) {
-      // exactly 0.5 and ODD, then round up
-      // 1.5 -> 2, but 2.5 -> 2
-      ++whole;
-    }
-  }
-  else {
-    unsigned int count = prec;
-    // now do fractional part, as an unsigned number
-    while (len < PRINTF_FTOA_BUFFER_SIZE) {
-      --count;
-      buf[len++] = (char)(48U + (frac % 10U));
-      if (!(frac /= 10U)) {
-        break;
-      }
-    }
-    // add extra 0s
-    while ((len < PRINTF_FTOA_BUFFER_SIZE) && (count-- > 0U)) {
-      buf[len++] = '0';
-    }
-    if (len < PRINTF_FTOA_BUFFER_SIZE) {
-      // add decimal
-      buf[len++] = '.';
-    }
-  }
-
-  // do whole part, number is reversed
-  while (len < PRINTF_FTOA_BUFFER_SIZE) {
-    buf[len++] = (char)(48 + (whole % 10));
-    if (!(whole /= 10)) {
-      break;
-    }
-  }
-
-  // pad leading zeros
-  if (!(flags & FLAGS_LEFT) && (flags & FLAGS_ZEROPAD)) {
-    if (width && (negative || (flags & (FLAGS_PLUS | FLAGS_SPACE)))) {
-      width--;
-    }
-    while ((len < width) && (len < PRINTF_FTOA_BUFFER_SIZE)) {
-      buf[len++] = '0';
-    }
-  }
-
-  if (len < PRINTF_FTOA_BUFFER_SIZE) {
-    if (negative) {
-      buf[len++] = '-';
-    }
-    else if (flags & FLAGS_PLUS) {
-      buf[len++] = '+';  // ignore the space if the '+' exists
-    }
-    else if (flags & FLAGS_SPACE) {
-      buf[len++] = ' ';
-    }
-  }
-
-  return _out_rev(out, buffer, idx, maxlen, buf, len, width, flags);
-}
-
-
-#if defined(PRINTF_SUPPORT_EXPONENTIAL)
-// internal ftoa variant for exponential floating-point type, contributed by Martijn Jasperse <m.jasperse@gmail.com>
-static size_t _etoa(out_fct_type out, char* buffer, size_t idx, size_t maxlen, double value, unsigned int prec, unsigned int width, unsigned int flags)
-{
-  // check for NaN and special values
-  if ((value != value) || (value > DBL_MAX) || (value < -DBL_MAX)) {
-    return _ftoa(out, buffer, idx, maxlen, value, prec, width, flags);
-  }
-
-  // determine the sign
-  const bool negative = value < 0;
-  if (negative) {
-    value = -value;
-  }
-
-  // default precision
-  if (!(flags & FLAGS_PRECISION)) {
-    prec = PRINTF_DEFAULT_FLOAT_PRECISION;
-  }
-
-  // determine the decimal exponent
-  // based on the algorithm by David Gay (https://www.ampl.com/netlib/fp/dtoa.c)
-  union {
-    uint64_t U;
-    double   F;
-  } conv;
-
-  conv.F = value;
-  int exp2 = (int)((conv.U >> 52U) & 0x07FFU) - 1023;           // effectively log2
-  conv.U = (conv.U & ((1ULL << 52U) - 1U)) | (1023ULL << 52U);  // drop the exponent so conv.F is now in [1,2)
-  // now approximate log10 from the log2 integer part and an expansion of ln around 1.5
-  int expval = (int)(0.1760912590558 + exp2 * 0.301029995663981 + (conv.F - 1.5) * 0.289529654602168);
-  // now we want to compute 10^expval but we want to be sure it won't overflow
-  exp2 = (int)(expval * 3.321928094887362 + 0.5);
-  const double z  = expval * 2.302585092994046 - exp2 * 0.6931471805599453;
-  const double z2 = z * z;
-  conv.U = (uint64_t)(exp2 + 1023) << 52U;
-  // compute exp(z) using continued fractions, see https://en.wikipedia.org/wiki/Exponential_function#Continued_fractions_for_ex
-  conv.F *= 1 + 2 * z / (2 - z + (z2 / (6 + (z2 / (10 + z2 / 14)))));
-  // correct for rounding errors
-  if (value < conv.F) {
-    expval--;
-    conv.F /= 10;
-  }
-
-  // the exponent format is "%+03d" and largest value is "307", so set aside 4-5 characters
-  unsigned int minwidth = ((expval < 100) && (expval > -100)) ? 4U : 5U;
-
-  // in "%g" mode, "prec" is the number of *significant figures* not decimals
-  if (flags & FLAGS_ADAPT_EXP) {
-    // do we want to fall-back to "%f" mode?
-    if ((value >= 1e-4) && (value < 1e6)) {
-      if ((int)prec > expval) {
-        prec = (unsigned)((int)prec - expval - 1);
-      }
-      else {
-        prec = 0;
-      }
-      flags |= FLAGS_PRECISION;   // make sure _ftoa respects precision
-      // no characters in exponent
-      minwidth = 0U;
-      expval   = 0;
-    }
-    else {
-      // we use one sigfig for the whole part
-      if ((prec > 0) && (flags & FLAGS_PRECISION)) {
-        --prec;
-      }
-    }
-  }
-
-  // will everything fit?
-  unsigned int fwidth = width;
-  if (width > minwidth) {
-    // we didn't fall-back so subtract the characters required for the exponent
-    fwidth -= minwidth;
-  } else {
-    // not enough characters, so go back to default sizing
-    fwidth = 0U;
-  }
-  if ((flags & FLAGS_LEFT) && minwidth) {
-    // if we're padding on the right, DON'T pad the floating part
-    fwidth = 0U;
-  }
-
-  // rescale the float value
-  if (expval) {
-    value /= conv.F;
-  }
-
-  // output the floating part
-  const size_t start_idx = idx;
-  idx = _ftoa(out, buffer, idx, maxlen, negative ? -value : value, prec, fwidth, flags & ~FLAGS_ADAPT_EXP);
-
-  // output the exponent part
-  if (minwidth) {
-    // output the exponential symbol
-    out((flags & FLAGS_UPPERCASE) ? 'E' : 'e', buffer, idx++, maxlen);
-    // output the exponent value
-    idx = _ntoa_long(out, buffer, idx, maxlen, (expval < 0) ? -expval : expval, expval < 0, 10, 0, minwidth-1, FLAGS_ZEROPAD | FLAGS_PLUS);
-    // might need to right-pad spaces
-    if (flags & FLAGS_LEFT) {
-      while (idx - start_idx < width) out(' ', buffer, idx++, maxlen);
-    }
-  }
-  return idx;
-}
-#endif  // PRINTF_SUPPORT_EXPONENTIAL
-#endif  // PRINTF_SUPPORT_FLOAT
-
-
-// internal vsnprintf
-static int _vsnprintf(out_fct_type out, char* buffer, const size_t maxlen, const char* format, va_list va)
-{
-  unsigned int flags, width, precision, n;
-  size_t idx = 0U;
-
-  if (!buffer) {
-    // use null output function
-    out = _out_null;
-  }
-
-  while (*format)
-  {
-    // format specifier?  %[flags][width][.precision][length]
-    if (*format != '%') {
-      // no
-      out(*format, buffer, idx++, maxlen);
-      format++;
-      continue;
-    }
-    else {
-      // yes, evaluate it
-      format++;
-    }
-
-    // evaluate flags
-    flags = 0U;
-    do {
-      switch (*format) {
-        case '0': flags |= FLAGS_ZEROPAD; format++; n = 1U; break;
-        case '-': flags |= FLAGS_LEFT;    format++; n = 1U; break;
-        case '+': flags |= FLAGS_PLUS;    format++; n = 1U; break;
-        case ' ': flags |= FLAGS_SPACE;   format++; n = 1U; break;
-        case '#': flags |= FLAGS_HASH;    format++; n = 1U; break;
-        default :                                   n = 0U; break;
-      }
-    } while (n);
-
-    // evaluate width field
-    width = 0U;
-    if (_is_digit(*format)) {
-      width = _atoi(&format);
-    }
-    else if (*format == '*') {
-      const int w = va_arg(va, int);
-      if (w < 0) {
-        flags |= FLAGS_LEFT;    // reverse padding
-        width = (unsigned int)-w;
-      }
-      else {
-        width = (unsigned int)w;
-      }
-      format++;
-    }
-
-    // evaluate precision field
-    precision = 0U;
-    if (*format == '.') {
-      flags |= FLAGS_PRECISION;
-      format++;
-      if (_is_digit(*format)) {
-        precision = _atoi(&format);
-      }
-      else if (*format == '*') {
-        const int prec = (int)va_arg(va, int);
-        precision = prec > 0 ? (unsigned int)prec : 0U;
-        format++;
-      }
-    }
-
-    // evaluate length field
-    switch (*format) {
-      case 'l' :
-        flags |= FLAGS_LONG;
-        format++;
-        if (*format == 'l') {
-          flags |= FLAGS_LONG_LONG;
-          format++;
-        }
-        break;
-      case 'h' :
-        flags |= FLAGS_SHORT;
-        format++;
-        if (*format == 'h') {
-          flags |= FLAGS_CHAR;
-          format++;
-        }
-        break;
-#if defined(PRINTF_SUPPORT_PTRDIFF_T)
-      case 't' :
-        flags |= (sizeof(ptrdiff_t) == sizeof(long) ? FLAGS_LONG : FLAGS_LONG_LONG);
-        format++;
-        break;
-#endif
-      case 'j' :
-        flags |= (sizeof(intmax_t) == sizeof(long) ? FLAGS_LONG : FLAGS_LONG_LONG);
-        format++;
-        break;
-      case 'z' :
-        flags |= (sizeof(size_t) == sizeof(long) ? FLAGS_LONG : FLAGS_LONG_LONG);
-        format++;
-        break;
-      default :
-        break;
-    }
-
-    // evaluate specifier
-    switch (*format) {
-      case 'd' :
-      case 'i' :
-      case 'u' :
-      case 'x' :
-      case 'X' :
-      case 'o' :
-      case 'b' : {
-        // set the base
-        unsigned int base;
-        if (*format == 'x' || *format == 'X') {
-          base = 16U;
-        }
-        else if (*format == 'o') {
-          base =  8U;
-        }
-        else if (*format == 'b') {
-          base =  2U;
-        }
-        else {
-          base = 10U;
-          flags &= ~FLAGS_HASH;   // no hash for dec format
-        }
-        // uppercase
-        if (*format == 'X') {
-          flags |= FLAGS_UPPERCASE;
-        }
-
-        // no plus or space flag for u, x, X, o, b
-        if ((*format != 'i') && (*format != 'd')) {
-          flags &= ~(FLAGS_PLUS | FLAGS_SPACE);
-        }
-
-        // ignore '0' flag when precision is given
-        if (flags & FLAGS_PRECISION) {
-          flags &= ~FLAGS_ZEROPAD;
-        }
-
-        // convert the integer
-        if ((*format == 'i') || (*format == 'd')) {
-          // signed
-          if (flags & FLAGS_LONG_LONG) {
-#if defined(PRINTF_SUPPORT_LONG_LONG)
-            const long long value = va_arg(va, long long);
-            idx = _ntoa_long_long(out, buffer, idx, maxlen, (unsigned long long)(value > 0 ? value : 0 - value), value < 0, base, precision, width, flags);
-#endif
-          }
-          else if (flags & FLAGS_LONG) {
-            const long value = va_arg(va, long);
-            idx = _ntoa_long(out, buffer, idx, maxlen, (unsigned long)(value > 0 ? value : 0 - value), value < 0, base, precision, width, flags);
-          }
-          else {
-            const int value = (flags & FLAGS_CHAR) ? (char)va_arg(va, int) : (flags & FLAGS_SHORT) ? (short int)va_arg(va, int) : va_arg(va, int);
-            idx = _ntoa_long(out, buffer, idx, maxlen, (unsigned int)(value > 0 ? value : 0 - value), value < 0, base, precision, width, flags);
-          }
-        }
-        else {
-          // unsigned
-          if (flags & FLAGS_LONG_LONG) {
-#if defined(PRINTF_SUPPORT_LONG_LONG)
-            idx = _ntoa_long_long(out, buffer, idx, maxlen, va_arg(va, unsigned long long), false, base, precision, width, flags);
-#endif
-          }
-          else if (flags & FLAGS_LONG) {
-            idx = _ntoa_long(out, buffer, idx, maxlen, va_arg(va, unsigned long), false, base, precision, width, flags);
-          }
-          else {
-            const unsigned int value = (flags & FLAGS_CHAR) ? (unsigned char)va_arg(va, unsigned int) : (flags & FLAGS_SHORT) ? (unsigned short int)va_arg(va, unsigned int) : va_arg(va, unsigned int);
-            idx = _ntoa_long(out, buffer, idx, maxlen, value, false, base, precision, width, flags);
-          }
-        }
-        format++;
-        break;
-      }
-#if defined(PRINTF_SUPPORT_FLOAT)
-      case 'f' :
-      case 'F' :
-        if (*format == 'F') flags |= FLAGS_UPPERCASE;
-        idx = _ftoa(out, buffer, idx, maxlen, va_arg(va, double), precision, width, flags);
-        format++;
-        break;
-#if defined(PRINTF_SUPPORT_EXPONENTIAL)
-      case 'e':
-      case 'E':
-      case 'g':
-      case 'G':
-        if ((*format == 'g')||(*format == 'G')) flags |= FLAGS_ADAPT_EXP;
-        if ((*format == 'E')||(*format == 'G')) flags |= FLAGS_UPPERCASE;
-        idx = _etoa(out, buffer, idx, maxlen, va_arg(va, double), precision, width, flags);
-        format++;
-        break;
-#endif  // PRINTF_SUPPORT_EXPONENTIAL
-#endif  // PRINTF_SUPPORT_FLOAT
-      case 'c' : {
-        unsigned int l = 1U;
-        // pre padding
-        if (!(flags & FLAGS_LEFT)) {
-          while (l++ < width) {
-            out(' ', buffer, idx++, maxlen);
-          }
-        }
-        // char output
-        out((char)va_arg(va, int), buffer, idx++, maxlen);
-        // post padding
-        if (flags & FLAGS_LEFT) {
-          while (l++ < width) {
-            out(' ', buffer, idx++, maxlen);
-          }
-        }
-        format++;
-        break;
-      }
-
-      case 's' : {
-        const char* p = va_arg(va, char*);
-        unsigned int l = _strnlen_s(p, precision ? precision : (size_t)-1);
-        // pre padding
-        if (flags & FLAGS_PRECISION) {
-          l = (l < precision ? l : precision);
-        }
-        if (!(flags & FLAGS_LEFT)) {
-          while (l++ < width) {
-            out(' ', buffer, idx++, maxlen);
-          }
-        }
-        // string output
-        while ((*p != 0) && (!(flags & FLAGS_PRECISION) || precision--)) {
-          out(*(p++), buffer, idx++, maxlen);
-        }
-        // post padding
-        if (flags & FLAGS_LEFT) {
-          while (l++ < width) {
-            out(' ', buffer, idx++, maxlen);
-          }
-        }
-        format++;
-        break;
-      }
-
-      case 'p' : {
-        width = sizeof(void*) * 2U;
-        flags |= FLAGS_ZEROPAD | FLAGS_UPPERCASE;
-#if defined(PRINTF_SUPPORT_LONG_LONG)
-        const bool is_ll = sizeof(uintptr_t) == sizeof(long long);
-        if (is_ll) {
-          idx = _ntoa_long_long(out, buffer, idx, maxlen, (uintptr_t)va_arg(va, void*), false, 16U, precision, width, flags);
-        }
-        else {
-#endif
-          idx = _ntoa_long(out, buffer, idx, maxlen, (unsigned long)((uintptr_t)va_arg(va, void*)), false, 16U, precision, width, flags);
-#if defined(PRINTF_SUPPORT_LONG_LONG)
-        }
-#endif
-        format++;
-        break;
-      }
-
-      case '%' :
-        out('%', buffer, idx++, maxlen);
-        format++;
-        break;
-
-      default :
-        out(*format, buffer, idx++, maxlen);
-        format++;
-        break;
-    }
-  }
-
-  // termination
-  out((char)0, buffer, idx < maxlen ? idx : maxlen - 1U, maxlen);
-
-  // return written chars without terminating \0
-  return (int)idx;
-}
-
-
-///////////////////////////////////////////////////////////////////////////////
-
-int printf_(const char* format, ...)
-{
-  va_list va;
-  va_start(va, format);
-  char buffer[1];
-  const int ret = _vsnprintf(_out_char, buffer, (size_t)-1, format, va);
-  va_end(va);
-  _putchar('\n');
-  return ret;
-}
-
-
-int sprintf_(char* buffer, const char* format, ...)
-{
-  va_list va;
-  va_start(va, format);
-  const int ret = _vsnprintf(_out_buffer, buffer, (size_t)-1, format, va);
-  va_end(va);
-  return ret;
-}
-
-
-int snprintf_(char* buffer, size_t count, const char* format, ...)
-{
-  va_list va;
-  va_start(va, format);
-  const int ret = _vsnprintf(_out_buffer, buffer, count, format, va);
-  va_end(va);
-  return ret;
-}
-
-
-int vprintf_(const char* format, va_list va)
-{
-  char buffer[1];
-  return _vsnprintf(_out_char, buffer, (size_t)-1, format, va);
-}
-
-
-int vsnprintf_(char* buffer, size_t count, const char* format, va_list va)
-{
-  return _vsnprintf(_out_buffer, buffer, count, format, va);
-}
-
-
-int fctprintf(void (*out)(char character, void* arg), void* arg, const char* format, ...)
-{
-  va_list va;
-  va_start(va, format);
-  const out_fct_wrap_type out_fct_wrap = { out, arg };
-  const int ret = _vsnprintf(_out_fct, (char*)(uintptr_t)&out_fct_wrap, (size_t)-1, format, va);
-  va_end(va);
-  return ret;
-}

src/libcoreio/Cargo.toml

@@ -0,0 +1,14 @@
+[package]
+authors = ["M-Labs"]
+name = "core_io"
+version = "0.1.20200410"
+
+[lib]
+name = "core_io"
+
+[dependencies]
+memchr = { version = "2", default-features = false, optional = true }
+
+[features]
+alloc = []
+collections = ["alloc", "memchr"]

src/libcoreio/src/io/cursor.rs

@@ -0,0 +1,896 @@
+use crate::io::prelude::*;
+
+use core::cmp;
+use crate::io::{self, Error, ErrorKind, Initializer, SeekFrom};
+
+#[cfg(feature = "collections")]
+use core::convert::TryInto;
+
+#[cfg(feature="collections")] 
+use collections::vec::Vec;
+
+#[cfg(feature = "alloc")]
+use alloc::boxed::Box;
+
+/// A `Cursor` wraps an in-memory buffer and provides it with a
+/// [`Seek`] implementation.
+///
+/// `Cursor`s are used with in-memory buffers, anything implementing
+/// `AsRef<[u8]>`, to allow them to implement [`Read`] and/or [`Write`],
+/// allowing these buffers to be used anywhere you might use a reader or writer
+/// that does actual I/O.
+///
+/// The standard library implements some I/O traits on various types which
+/// are commonly used as a buffer, like `Cursor<`[`Vec`]`<u8>>` and
+/// `Cursor<`[`&[u8]`][bytes]`>`.
+///
+/// # Examples
+///
+/// We may want to write bytes to a [`File`] in our production
+/// code, but use an in-memory buffer in our tests. We can do this with
+/// `Cursor`:
+///
+/// [`Seek`]: trait.Seek.html
+/// [`Read`]: ../../std/io/trait.Read.html
+/// [`Write`]: ../../std/io/trait.Write.html
+/// [`Vec`]: ../../std/vec/struct.Vec.html
+/// [bytes]: ../../std/primitive.slice.html
+/// [`File`]: ../fs/struct.File.html
+///
+/// ```no_run
+/// use std::io::prelude::*;
+/// use std::io::{self, SeekFrom};
+/// use std::fs::File;
+///
+/// // a library function we've written
+/// fn write_ten_bytes_at_end<W: Write + Seek>(writer: &mut W) -> io::Result<()> {
+///     writer.seek(SeekFrom::End(-10))?;
+///
+///     for i in 0..10 {
+///         writer.write(&[i])?;
+///     }
+///
+///     // all went well
+///     Ok(())
+/// }
+///
+/// # fn foo() -> io::Result<()> {
+/// // Here's some code that uses this library function.
+/// //
+/// // We might want to use a BufReader here for efficiency, but let's
+/// // keep this example focused.
+/// let mut file = File::create("foo.txt")?;
+///
+/// write_ten_bytes_at_end(&mut file)?;
+/// # Ok(())
+/// # }
+///
+/// // now let's write a test
+/// #[test]
+/// fn test_writes_bytes() {
+///     // setting up a real File is much slower than an in-memory buffer,
+///     // let's use a cursor instead
+///     use std::io::Cursor;
+///     let mut buff = Cursor::new(vec![0; 15]);
+///
+///     write_ten_bytes_at_end(&mut buff).unwrap();
+///
+///     assert_eq!(&buff.get_ref()[5..15], &[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]);
+/// }
+/// ```
+#[derive(Clone, Debug, Default, Eq, PartialEq)]
+pub struct Cursor<T> {
+    inner: T,
+    pos: u64,
+}
+
+impl<T> Cursor<T> {
+    /// Creates a new cursor wrapping the provided underlying in-memory buffer.
+    ///
+    /// Cursor initial position is `0` even if underlying buffer (e.g., `Vec`)
+    /// is not empty. So writing to cursor starts with overwriting `Vec`
+    /// content, not with appending to it.
+    ///
+    /// # Examples
+    ///
+    /// ```
+    /// use std::io::Cursor;
+    ///
+    /// let buff = Cursor::new(Vec::new());
+    /// # fn force_inference(_: &Cursor<Vec<u8>>) {}
+    /// # force_inference(&buff);
+    /// ```
+    pub fn new(inner: T) -> Cursor<T> {
+        Cursor { pos: 0, inner }
+    }
+
+    /// Consumes this cursor, returning the underlying value.
+    ///
+    /// # Examples
+    ///
+    /// ```
+    /// use std::io::Cursor;
+    ///
+    /// let buff = Cursor::new(Vec::new());
+    /// # fn force_inference(_: &Cursor<Vec<u8>>) {}
+    /// # force_inference(&buff);
+    ///
+    /// let vec = buff.into_inner();
+    /// ```
+    pub fn into_inner(self) -> T {
+        self.inner
+    }
+
+    /// Gets a reference to the underlying value in this cursor.
+    ///
+    /// # Examples
+    ///
+    /// ```
+    /// use std::io::Cursor;
+    ///
+    /// let buff = Cursor::new(Vec::new());
+    /// # fn force_inference(_: &Cursor<Vec<u8>>) {}
+    /// # force_inference(&buff);
+    ///
+    /// let reference = buff.get_ref();
+    /// ```
+    pub fn get_ref(&self) -> &T {
+        &self.inner
+    }
+
+    /// Gets a mutable reference to the underlying value in this cursor.
+    ///
+    /// Care should be taken to avoid modifying the internal I/O state of the
+    /// underlying value as it may corrupt this cursor's position.
+    ///
+    /// # Examples
+    ///
+    /// ```
+    /// use std::io::Cursor;
+    ///
+    /// let mut buff = Cursor::new(Vec::new());
+    /// # fn force_inference(_: &Cursor<Vec<u8>>) {}
+    /// # force_inference(&buff);
+    ///
+    /// let reference = buff.get_mut();
+    /// ```
+    pub fn get_mut(&mut self) -> &mut T {
+        &mut self.inner
+    }
+
+    /// Returns the current position of this cursor.
+    ///
+    /// # Examples
+    ///
+    /// ```
+    /// use std::io::Cursor;
+    /// use std::io::prelude::*;
+    /// use std::io::SeekFrom;
+    ///
+    /// let mut buff = Cursor::new(vec![1, 2, 3, 4, 5]);
+    ///
+    /// assert_eq!(buff.position(), 0);
+    ///
+    /// buff.seek(SeekFrom::Current(2)).unwrap();
+    /// assert_eq!(buff.position(), 2);
+    ///
+    /// buff.seek(SeekFrom::Current(-1)).unwrap();
+    /// assert_eq!(buff.position(), 1);
+    /// ```
+    pub fn position(&self) -> u64 {
+        self.pos
+    }
+
+    /// Sets the position of this cursor.
+    ///
+    /// # Examples
+    ///
+    /// ```
+    /// use std::io::Cursor;
+    ///
+    /// let mut buff = Cursor::new(vec![1, 2, 3, 4, 5]);
+    ///
+    /// assert_eq!(buff.position(), 0);
+    ///
+    /// buff.set_position(2);
+    /// assert_eq!(buff.position(), 2);
+    ///
+    /// buff.set_position(4);
+    /// assert_eq!(buff.position(), 4);
+    /// ```
+    pub fn set_position(&mut self, pos: u64) {
+        self.pos = pos;
+    }
+}
+
+impl<T> io::Seek for Cursor<T>
+where
+    T: AsRef<[u8]>,
+{
+    fn seek(&mut self, style: SeekFrom) -> io::Result<u64> {
+        let (base_pos, offset) = match style {
+            SeekFrom::Start(n) => {
+                self.pos = n;
+                return Ok(n);
+            }
+            SeekFrom::End(n) => (self.inner.as_ref().len() as u64, n),
+            SeekFrom::Current(n) => (self.pos, n),
+        };
+        let new_pos = if offset >= 0 {
+            base_pos.checked_add(offset as u64)
+        } else {
+            base_pos.checked_sub((offset.wrapping_neg()) as u64)
+        };
+        match new_pos {
+            Some(n) => {
+                self.pos = n;
+                Ok(self.pos)
+            }
+            None => Err(Error::new(
+                ErrorKind::InvalidInput,
+                "invalid seek to a negative or overflowing position",
+            )),
+        }
+    }
+
+    fn stream_len(&mut self) -> io::Result<u64> {
+        Ok(self.inner.as_ref().len() as u64)
+    }
+
+    fn stream_position(&mut self) -> io::Result<u64> {
+        Ok(self.pos)
+    }
+}
+
+impl<T> Read for Cursor<T>
+where
+    T: AsRef<[u8]>,
+{
+    fn read(&mut self, buf: &mut [u8]) -> io::Result<usize> {
+        let n = Read::read(&mut self.get_ref().as_ref(), buf)?;
+        self.pos += n as u64;
+        Ok(n)
+    }
+
+    fn read_exact(&mut self, buf: &mut [u8]) -> io::Result<()> {
+        let n = buf.len();
+        Read::read_exact(&mut self.get_ref().as_ref(), buf)?;
+        self.pos += n as u64;
+        Ok(())
+    }
+
+    #[inline]
+    unsafe fn initializer(&self) -> Initializer {
+        Initializer::nop()
+    }
+}
+
+#[cfg(feature = "collections")]
+impl<T> BufRead for Cursor<T>
+where
+    T: AsRef<[u8]>,
+{
+    fn fill_buf(&mut self) -> io::Result<&[u8]> {
+        let amt = cmp::min(self.pos, self.inner.as_ref().len() as u64);
+        Ok(&self.inner.as_ref()[(amt as usize)..])
+    }
+    fn consume(&mut self, amt: usize) {
+        self.pos += amt as u64;
+    }
+}
+
+// Non-resizing write implementation
+#[inline]
+fn slice_write(pos_mut: &mut u64, slice: &mut [u8], buf: &[u8]) -> io::Result<usize> {
+    let pos = cmp::min(*pos_mut, slice.len() as u64);
+    let amt = (&mut slice[(pos as usize)..]).write(buf)?;
+    *pos_mut += amt as u64;
+    Ok(amt)
+}
+
+// Resizing write implementation
+#[cfg(feature = "collections")]
+fn vec_write(pos_mut: &mut u64, vec: &mut Vec<u8>, buf: &[u8]) -> io::Result<usize> {
+    let pos: usize = (*pos_mut).try_into().map_err(|_| {
+        Error::new(
+            ErrorKind::InvalidInput,
+            "cursor position exceeds maximum possible vector length",
+        )
+    })?;
+    // Make sure the internal buffer is as least as big as where we
+    // currently are
+    let len = vec.len();
+    if len < pos {
+        // use `resize` so that the zero filling is as efficient as possible
+        vec.resize(pos, 0);
+    }
+    // Figure out what bytes will be used to overwrite what's currently
+    // there (left), and what will be appended on the end (right)
+    {
+        let space = vec.len() - pos;
+        let (left, right) = buf.split_at(cmp::min(space, buf.len()));
+        vec[pos..pos + left.len()].copy_from_slice(left);
+        vec.extend_from_slice(right);
+    }
+
+    // Bump us forward
+    *pos_mut = (pos + buf.len()) as u64;
+    Ok(buf.len())
+}
+
+impl Write for Cursor<&mut [u8]> {
+    #[inline]
+    fn write(&mut self, buf: &[u8]) -> io::Result<usize> {
+        slice_write(&mut self.pos, self.inner, buf)
+    }
+
+    #[inline]
+    fn flush(&mut self) -> io::Result<()> {
+        Ok(())
+    }
+}
+
+#[cfg(feature = "collections")]
+impl Write for Cursor<&mut Vec<u8>> {
+    fn write(&mut self, buf: &[u8]) -> io::Result<usize> {
+        vec_write(&mut self.pos, self.inner, buf)
+    }
+
+    #[inline]
+    fn flush(&mut self) -> io::Result<()> {
+        Ok(())
+    }
+}
+
+#[cfg(feature = "collections")]
+impl Write for Cursor<Vec<u8>> {
+    fn write(&mut self, buf: &[u8]) -> io::Result<usize> {
+        vec_write(&mut self.pos, &mut self.inner, buf)
+    }
+
+    #[inline]
+    fn flush(&mut self) -> io::Result<()> {
+        Ok(())
+    }
+}
+
+#[cfg(feature = "alloc")]
+impl Write for Cursor<Box<[u8]>> {
+    #[inline]
+    fn write(&mut self, buf: &[u8]) -> io::Result<usize> {
+        slice_write(&mut self.pos, &mut self.inner, buf)
+    }
+
+    #[inline]
+    fn flush(&mut self) -> io::Result<()> {
+        Ok(())
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use crate::io::prelude::*;
+    use crate::io::{Cursor, IoSlice, IoSliceMut, SeekFrom};
+
+    #[test]
+    fn test_vec_writer() {
+        let mut writer = Vec::new();
+        assert_eq!(writer.write(&[0]).unwrap(), 1);
+        assert_eq!(writer.write(&[1, 2, 3]).unwrap(), 3);
+        assert_eq!(writer.write(&[4, 5, 6, 7]).unwrap(), 4);
+        assert_eq!(
+            writer
+                .write_vectored(&[IoSlice::new(&[]), IoSlice::new(&[8, 9]), IoSlice::new(&[10])],)
+                .unwrap(),
+            3
+        );
+        let b: &[_] = &[0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10];
+        assert_eq!(writer, b);
+    }
+
+    #[test]
+    fn test_mem_writer() {
+        let mut writer = Cursor::new(Vec::new());
+        assert_eq!(writer.write(&[0]).unwrap(), 1);
+        assert_eq!(writer.write(&[1, 2, 3]).unwrap(), 3);
+        assert_eq!(writer.write(&[4, 5, 6, 7]).unwrap(), 4);
+        assert_eq!(
+            writer
+                .write_vectored(&[IoSlice::new(&[]), IoSlice::new(&[8, 9]), IoSlice::new(&[10])],)
+                .unwrap(),
+            3
+        );
+        let b: &[_] = &[0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10];
+        assert_eq!(&writer.get_ref()[..], b);
+    }
+
+    #[test]
+    fn test_mem_mut_writer() {
+        let mut vec = Vec::new();
+        let mut writer = Cursor::new(&mut vec);
+        assert_eq!(writer.write(&[0]).unwrap(), 1);
+        assert_eq!(writer.write(&[1, 2, 3]).unwrap(), 3);
+        assert_eq!(writer.write(&[4, 5, 6, 7]).unwrap(), 4);
+        assert_eq!(
+            writer
+                .write_vectored(&[IoSlice::new(&[]), IoSlice::new(&[8, 9]), IoSlice::new(&[10])],)
+                .unwrap(),
+            3
+        );
+        let b: &[_] = &[0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10];
+        assert_eq!(&writer.get_ref()[..], b);
+    }
+
+    #[test]
+    fn test_box_slice_writer() {
+        let mut writer = Cursor::new(vec![0u8; 9].into_boxed_slice());
+        assert_eq!(writer.position(), 0);
+        assert_eq!(writer.write(&[0]).unwrap(), 1);
+        assert_eq!(writer.position(), 1);
+        assert_eq!(writer.write(&[1, 2, 3]).unwrap(), 3);
+        assert_eq!(writer.write(&[4, 5, 6, 7]).unwrap(), 4);
+        assert_eq!(writer.position(), 8);
+        assert_eq!(writer.write(&[]).unwrap(), 0);
+        assert_eq!(writer.position(), 8);
+
+        assert_eq!(writer.write(&[8, 9]).unwrap(), 1);
+        assert_eq!(writer.write(&[10]).unwrap(), 0);
+        let b: &[_] = &[0, 1, 2, 3, 4, 5, 6, 7, 8];
+        assert_eq!(&**writer.get_ref(), b);
+    }
+
+    #[test]
+    fn test_box_slice_writer_vectored() {
+        let mut writer = Cursor::new(vec![0u8; 9].into_boxed_slice());
+        assert_eq!(writer.position(), 0);
+        assert_eq!(writer.write_vectored(&[IoSlice::new(&[0])]).unwrap(), 1);
+        assert_eq!(writer.position(), 1);
+        assert_eq!(
+            writer
+                .write_vectored(&[IoSlice::new(&[1, 2, 3]), IoSlice::new(&[4, 5, 6, 7]),])
+                .unwrap(),
+            7,
+        );
+        assert_eq!(writer.position(), 8);
+        assert_eq!(writer.write_vectored(&[]).unwrap(), 0);
+        assert_eq!(writer.position(), 8);
+
+        assert_eq!(writer.write_vectored(&[IoSlice::new(&[8, 9])]).unwrap(), 1);
+        assert_eq!(writer.write_vectored(&[IoSlice::new(&[10])]).unwrap(), 0);
+        let b: &[_] = &[0, 1, 2, 3, 4, 5, 6, 7, 8];
+        assert_eq!(&**writer.get_ref(), b);
+    }
+
+    #[test]
+    fn test_buf_writer() {
+        let mut buf = [0 as u8; 9];
+        {
+            let mut writer = Cursor::new(&mut buf[..]);
+            assert_eq!(writer.position(), 0);
+            assert_eq!(writer.write(&[0]).unwrap(), 1);
+            assert_eq!(writer.position(), 1);
+            assert_eq!(writer.write(&[1, 2, 3]).unwrap(), 3);
+            assert_eq!(writer.write(&[4, 5, 6, 7]).unwrap(), 4);
+            assert_eq!(writer.position(), 8);
+            assert_eq!(writer.write(&[]).unwrap(), 0);
+            assert_eq!(writer.position(), 8);
+
+            assert_eq!(writer.write(&[8, 9]).unwrap(), 1);
+            assert_eq!(writer.write(&[10]).unwrap(), 0);
+        }
+        let b: &[_] = &[0, 1, 2, 3, 4, 5, 6, 7, 8];
+        assert_eq!(buf, b);
+    }
+
+    #[test]
+    fn test_buf_writer_vectored() {
+        let mut buf = [0 as u8; 9];
+        {
+            let mut writer = Cursor::new(&mut buf[..]);
+            assert_eq!(writer.position(), 0);
+            assert_eq!(writer.write_vectored(&[IoSlice::new(&[0])]).unwrap(), 1);
+            assert_eq!(writer.position(), 1);
+            assert_eq!(
+                writer
+                    .write_vectored(&[IoSlice::new(&[1, 2, 3]), IoSlice::new(&[4, 5, 6, 7])],)
+                    .unwrap(),
+                7,
+            );
+            assert_eq!(writer.position(), 8);
+            assert_eq!(writer.write_vectored(&[]).unwrap(), 0);
+            assert_eq!(writer.position(), 8);
+
+            assert_eq!(writer.write_vectored(&[IoSlice::new(&[8, 9])]).unwrap(), 1);
+            assert_eq!(writer.write_vectored(&[IoSlice::new(&[10])]).unwrap(), 0);
+        }
+        let b: &[_] = &[0, 1, 2, 3, 4, 5, 6, 7, 8];
+        assert_eq!(buf, b);
+    }
+
+    #[test]
+    fn test_buf_writer_seek() {
+        let mut buf = [0 as u8; 8];
+        {
+            let mut writer = Cursor::new(&mut buf[..]);
+            assert_eq!(writer.position(), 0);
+            assert_eq!(writer.write(&[1]).unwrap(), 1);
+            assert_eq!(writer.position(), 1);
+
+            assert_eq!(writer.seek(SeekFrom::Start(2)).unwrap(), 2);
+            assert_eq!(writer.position(), 2);
+            assert_eq!(writer.write(&[2]).unwrap(), 1);
+            assert_eq!(writer.position(), 3);
+
+            assert_eq!(writer.seek(SeekFrom::Current(-2)).unwrap(), 1);
+            assert_eq!(writer.position(), 1);
+            assert_eq!(writer.write(&[3]).unwrap(), 1);
+            assert_eq!(writer.position(), 2);
+
+            assert_eq!(writer.seek(SeekFrom::End(-1)).unwrap(), 7);
+            assert_eq!(writer.position(), 7);
+            assert_eq!(writer.write(&[4]).unwrap(), 1);
+            assert_eq!(writer.position(), 8);
+        }
+        let b: &[_] = &[1, 3, 2, 0, 0, 0, 0, 4];
+        assert_eq!(buf, b);
+    }
+
+    #[test]
+    fn test_buf_writer_error() {
+        let mut buf = [0 as u8; 2];
+        let mut writer = Cursor::new(&mut buf[..]);
+        assert_eq!(writer.write(&[0]).unwrap(), 1);
+        assert_eq!(writer.write(&[0, 0]).unwrap(), 1);
+        assert_eq!(writer.write(&[0, 0]).unwrap(), 0);
+    }
+
+    #[test]
+    fn test_mem_reader() {
+        let mut reader = Cursor::new(vec![0, 1, 2, 3, 4, 5, 6, 7]);
+        let mut buf = [];
+        assert_eq!(reader.read(&mut buf).unwrap(), 0);
+        assert_eq!(reader.position(), 0);
+        let mut buf = [0];
+        assert_eq!(reader.read(&mut buf).unwrap(), 1);
+        assert_eq!(reader.position(), 1);
+        let b: &[_] = &[0];
+        assert_eq!(buf, b);
+        let mut buf = [0; 4];
+        assert_eq!(reader.read(&mut buf).unwrap(), 4);
+        assert_eq!(reader.position(), 5);
+        let b: &[_] = &[1, 2, 3, 4];
+        assert_eq!(buf, b);
+        assert_eq!(reader.read(&mut buf).unwrap(), 3);
+        let b: &[_] = &[5, 6, 7];
+        assert_eq!(&buf[..3], b);
+        assert_eq!(reader.read(&mut buf).unwrap(), 0);
+    }
+
+    #[test]
+    fn test_mem_reader_vectored() {
+        let mut reader = Cursor::new(vec![0, 1, 2, 3, 4, 5, 6, 7]);
+        let mut buf = [];
+        assert_eq!(reader.read_vectored(&mut [IoSliceMut::new(&mut buf)]).unwrap(), 0);
+        assert_eq!(reader.position(), 0);
+        let mut buf = [0];
+        assert_eq!(
+            reader
+                .read_vectored(&mut [IoSliceMut::new(&mut []), IoSliceMut::new(&mut buf),])
+                .unwrap(),
+            1,
+        );
+        assert_eq!(reader.position(), 1);
+        let b: &[_] = &[0];
+        assert_eq!(buf, b);
+        let mut buf1 = [0; 4];
+        let mut buf2 = [0; 4];
+        assert_eq!(
+            reader
+                .read_vectored(&mut [IoSliceMut::new(&mut buf1), IoSliceMut::new(&mut buf2),])
+                .unwrap(),
+            7,
+        );
+        let b1: &[_] = &[1, 2, 3, 4];
+        let b2: &[_] = &[5, 6, 7];
+        assert_eq!(buf1, b1);
+        assert_eq!(&buf2[..3], b2);
+        assert_eq!(reader.read(&mut buf).unwrap(), 0);
+    }
+
+    #[test]
+    fn test_boxed_slice_reader() {
+        let mut reader = Cursor::new(vec![0, 1, 2, 3, 4, 5, 6, 7].into_boxed_slice());
+        let mut buf = [];
+        assert_eq!(reader.read(&mut buf).unwrap(), 0);
+        assert_eq!(reader.position(), 0);
+        let mut buf = [0];
+        assert_eq!(reader.read(&mut buf).unwrap(), 1);
+        assert_eq!(reader.position(), 1);
+        let b: &[_] = &[0];
+        assert_eq!(buf, b);
+        let mut buf = [0; 4];
+        assert_eq!(reader.read(&mut buf).unwrap(), 4);
+        assert_eq!(reader.position(), 5);
+        let b: &[_] = &[1, 2, 3, 4];
+        assert_eq!(buf, b);
+        assert_eq!(reader.read(&mut buf).unwrap(), 3);
+        let b: &[_] = &[5, 6, 7];
+        assert_eq!(&buf[..3], b);
+        assert_eq!(reader.read(&mut buf).unwrap(), 0);
+    }
+
+    #[test]
+    fn test_boxed_slice_reader_vectored() {
+        let mut reader = Cursor::new(vec![0, 1, 2, 3, 4, 5, 6, 7].into_boxed_slice());
+        let mut buf = [];
+        assert_eq!(reader.read_vectored(&mut [IoSliceMut::new(&mut buf)]).unwrap(), 0);
+        assert_eq!(reader.position(), 0);
+        let mut buf = [0];
+        assert_eq!(
+            reader
+                .read_vectored(&mut [IoSliceMut::new(&mut []), IoSliceMut::new(&mut buf),])
+                .unwrap(),
+            1,
+        );
+        assert_eq!(reader.position(), 1);
+        let b: &[_] = &[0];
+        assert_eq!(buf, b);
+        let mut buf1 = [0; 4];
+        let mut buf2 = [0; 4];
+        assert_eq!(
+            reader
+                .read_vectored(&mut [IoSliceMut::new(&mut buf1), IoSliceMut::new(&mut buf2)],)
+                .unwrap(),
+            7,
+        );
+        let b1: &[_] = &[1, 2, 3, 4];
+        let b2: &[_] = &[5, 6, 7];
+        assert_eq!(buf1, b1);
+        assert_eq!(&buf2[..3], b2);
+        assert_eq!(reader.read(&mut buf).unwrap(), 0);
+    }
+
+    #[test]
+    fn read_to_end() {
+        let mut reader = Cursor::new(vec![0, 1, 2, 3, 4, 5, 6, 7]);
+        let mut v = Vec::new();
+        reader.read_to_end(&mut v).unwrap();
+        assert_eq!(v, [0, 1, 2, 3, 4, 5, 6, 7]);
+    }
+
+    #[test]
+    fn test_slice_reader() {
+        let in_buf = vec![0, 1, 2, 3, 4, 5, 6, 7];
+        let reader = &mut &in_buf[..];
+        let mut buf = [];
+        assert_eq!(reader.read(&mut buf).unwrap(), 0);
+        let mut buf = [0];
+        assert_eq!(reader.read(&mut buf).unwrap(), 1);
+        assert_eq!(reader.len(), 7);
+        let b: &[_] = &[0];
+        assert_eq!(&buf[..], b);
+        let mut buf = [0; 4];
+        assert_eq!(reader.read(&mut buf).unwrap(), 4);
+        assert_eq!(reader.len(), 3);
+        let b: &[_] = &[1, 2, 3, 4];
+        assert_eq!(&buf[..], b);
+        assert_eq!(reader.read(&mut buf).unwrap(), 3);
+        let b: &[_] = &[5, 6, 7];
+        assert_eq!(&buf[..3], b);
+        assert_eq!(reader.read(&mut buf).unwrap(), 0);
+    }
+
+    #[test]
+    fn test_slice_reader_vectored() {
+        let in_buf = vec![0, 1, 2, 3, 4, 5, 6, 7];
+        let reader = &mut &in_buf[..];
+        let mut buf = [];
+        assert_eq!(reader.read_vectored(&mut [IoSliceMut::new(&mut buf)]).unwrap(), 0);
+        let mut buf = [0];
+        assert_eq!(
+            reader
+                .read_vectored(&mut [IoSliceMut::new(&mut []), IoSliceMut::new(&mut buf),])
+                .unwrap(),
+            1,
+        );
+        assert_eq!(reader.len(), 7);
+        let b: &[_] = &[0];
+        assert_eq!(buf, b);
+        let mut buf1 = [0; 4];
+        let mut buf2 = [0; 4];
+        assert_eq!(
+            reader
+                .read_vectored(&mut [IoSliceMut::new(&mut buf1), IoSliceMut::new(&mut buf2)],)
+                .unwrap(),
+            7,
+        );
+        let b1: &[_] = &[1, 2, 3, 4];
+        let b2: &[_] = &[5, 6, 7];
+        assert_eq!(buf1, b1);
+        assert_eq!(&buf2[..3], b2);
+        assert_eq!(reader.read(&mut buf).unwrap(), 0);
+    }
+
+    #[test]
+    fn test_read_exact() {
+        let in_buf = vec![0, 1, 2, 3, 4, 5, 6, 7];
+        let reader = &mut &in_buf[..];
+        let mut buf = [];
+        assert!(reader.read_exact(&mut buf).is_ok());
+        let mut buf = [8];
+        assert!(reader.read_exact(&mut buf).is_ok());
+        assert_eq!(buf[0], 0);
+        assert_eq!(reader.len(), 7);
+        let mut buf = [0, 0, 0, 0, 0, 0, 0];
+        assert!(reader.read_exact(&mut buf).is_ok());
+        assert_eq!(buf, [1, 2, 3, 4, 5, 6, 7]);
+        assert_eq!(reader.len(), 0);
+        let mut buf = [0];
+        assert!(reader.read_exact(&mut buf).is_err());
+    }
+
+    #[test]
+    fn test_buf_reader() {
+        let in_buf = vec![0, 1, 2, 3, 4, 5, 6, 7];
+        let mut reader = Cursor::new(&in_buf[..]);
+        let mut buf = [];
+        assert_eq!(reader.read(&mut buf).unwrap(), 0);
+        assert_eq!(reader.position(), 0);
+        let mut buf = [0];
+        assert_eq!(reader.read(&mut buf).unwrap(), 1);
+        assert_eq!(reader.position(), 1);
+        let b: &[_] = &[0];
+        assert_eq!(buf, b);
+        let mut buf = [0; 4];
+        assert_eq!(reader.read(&mut buf).unwrap(), 4);
+        assert_eq!(reader.position(), 5);
+        let b: &[_] = &[1, 2, 3, 4];
+        assert_eq!(buf, b);
+        assert_eq!(reader.read(&mut buf).unwrap(), 3);
+        let b: &[_] = &[5, 6, 7];
+        assert_eq!(&buf[..3], b);
+        assert_eq!(reader.read(&mut buf).unwrap(), 0);
+    }
+
+    #[test]
+    fn seek_past_end() {
+        let buf = [0xff];
+        let mut r = Cursor::new(&buf[..]);
+        assert_eq!(r.seek(SeekFrom::Start(10)).unwrap(), 10);
+        assert_eq!(r.read(&mut [0]).unwrap(), 0);
+
+        let mut r = Cursor::new(vec![10]);
+        assert_eq!(r.seek(SeekFrom::Start(10)).unwrap(), 10);
+        assert_eq!(r.read(&mut [0]).unwrap(), 0);
+
+        let mut buf = [0];
+        let mut r = Cursor::new(&mut buf[..]);
+        assert_eq!(r.seek(SeekFrom::Start(10)).unwrap(), 10);
+        assert_eq!(r.write(&[3]).unwrap(), 0);
+
+        let mut r = Cursor::new(vec![10].into_boxed_slice());
+        assert_eq!(r.seek(SeekFrom::Start(10)).unwrap(), 10);
+        assert_eq!(r.write(&[3]).unwrap(), 0);
+    }
+
+    #[test]
+    fn seek_past_i64() {
+        let buf = [0xff];
+        let mut r = Cursor::new(&buf[..]);
+        assert_eq!(r.seek(SeekFrom::Start(6)).unwrap(), 6);
+        assert_eq!(r.seek(SeekFrom::Current(0x7ffffffffffffff0)).unwrap(), 0x7ffffffffffffff6);
+        assert_eq!(r.seek(SeekFrom::Current(0x10)).unwrap(), 0x8000000000000006);
+        assert_eq!(r.seek(SeekFrom::Current(0)).unwrap(), 0x8000000000000006);
+        assert!(r.seek(SeekFrom::Current(0x7ffffffffffffffd)).is_err());
+        assert_eq!(r.seek(SeekFrom::Current(-0x8000000000000000)).unwrap(), 6);
+
+        let mut r = Cursor::new(vec![10]);
+        assert_eq!(r.seek(SeekFrom::Start(6)).unwrap(), 6);
+        assert_eq!(r.seek(SeekFrom::Current(0x7ffffffffffffff0)).unwrap(), 0x7ffffffffffffff6);
+        assert_eq!(r.seek(SeekFrom::Current(0x10)).unwrap(), 0x8000000000000006);
+        assert_eq!(r.seek(SeekFrom::Current(0)).unwrap(), 0x8000000000000006);
+        assert!(r.seek(SeekFrom::Current(0x7ffffffffffffffd)).is_err());
+        assert_eq!(r.seek(SeekFrom::Current(-0x8000000000000000)).unwrap(), 6);
+
+        let mut buf = [0];
+        let mut r = Cursor::new(&mut buf[..]);
+        assert_eq!(r.seek(SeekFrom::Start(6)).unwrap(), 6);
+        assert_eq!(r.seek(SeekFrom::Current(0x7ffffffffffffff0)).unwrap(), 0x7ffffffffffffff6);
+        assert_eq!(r.seek(SeekFrom::Current(0x10)).unwrap(), 0x8000000000000006);
+        assert_eq!(r.seek(SeekFrom::Current(0)).unwrap(), 0x8000000000000006);
+        assert!(r.seek(SeekFrom::Current(0x7ffffffffffffffd)).is_err());
+        assert_eq!(r.seek(SeekFrom::Current(-0x8000000000000000)).unwrap(), 6);
+
+        let mut r = Cursor::new(vec![10].into_boxed_slice());
+        assert_eq!(r.seek(SeekFrom::Start(6)).unwrap(), 6);
+        assert_eq!(r.seek(SeekFrom::Current(0x7ffffffffffffff0)).unwrap(), 0x7ffffffffffffff6);
+        assert_eq!(r.seek(SeekFrom::Current(0x10)).unwrap(), 0x8000000000000006);
+        assert_eq!(r.seek(SeekFrom::Current(0)).unwrap(), 0x8000000000000006);
+        assert!(r.seek(SeekFrom::Current(0x7ffffffffffffffd)).is_err());
+        assert_eq!(r.seek(SeekFrom::Current(-0x8000000000000000)).unwrap(), 6);
+    }
+
+    #[test]
+    fn seek_before_0() {
+        let buf = [0xff];
+        let mut r = Cursor::new(&buf[..]);
+        assert!(r.seek(SeekFrom::End(-2)).is_err());
+
+        let mut r = Cursor::new(vec![10]);
+        assert!(r.seek(SeekFrom::End(-2)).is_err());
+
+        let mut buf = [0];
+        let mut r = Cursor::new(&mut buf[..]);
+        assert!(r.seek(SeekFrom::End(-2)).is_err());
+
+        let mut r = Cursor::new(vec![10].into_boxed_slice());
+        assert!(r.seek(SeekFrom::End(-2)).is_err());
+    }
+
+    #[test]
+    fn test_seekable_mem_writer() {
+        let mut writer = Cursor::new(Vec::<u8>::new());
+        assert_eq!(writer.position(), 0);
+        assert_eq!(writer.write(&[0]).unwrap(), 1);
+        assert_eq!(writer.position(), 1);
+        assert_eq!(writer.write(&[1, 2, 3]).unwrap(), 3);
+        assert_eq!(writer.write(&[4, 5, 6, 7]).unwrap(), 4);
+        assert_eq!(writer.position(), 8);
+        let b: &[_] = &[0, 1, 2, 3, 4, 5, 6, 7];
+        assert_eq!(&writer.get_ref()[..], b);
+
+        assert_eq!(writer.seek(SeekFrom::Start(0)).unwrap(), 0);
+        assert_eq!(writer.position(), 0);
+        assert_eq!(writer.write(&[3, 4]).unwrap(), 2);
+        let b: &[_] = &[3, 4, 2, 3, 4, 5, 6, 7];
+        assert_eq!(&writer.get_ref()[..], b);
+
+        assert_eq!(writer.seek(SeekFrom::Current(1)).unwrap(), 3);
+        assert_eq!(writer.write(&[0, 1]).unwrap(), 2);
+        let b: &[_] = &[3, 4, 2, 0, 1, 5, 6, 7];
+        assert_eq!(&writer.get_ref()[..], b);
+
+        assert_eq!(writer.seek(SeekFrom::End(-1)).unwrap(), 7);
+        assert_eq!(writer.write(&[1, 2]).unwrap(), 2);
+        let b: &[_] = &[3, 4, 2, 0, 1, 5, 6, 1, 2];
+        assert_eq!(&writer.get_ref()[..], b);
+
+        assert_eq!(writer.seek(SeekFrom::End(1)).unwrap(), 10);
+        assert_eq!(writer.write(&[1]).unwrap(), 1);
+        let b: &[_] = &[3, 4, 2, 0, 1, 5, 6, 1, 2, 0, 1];
+        assert_eq!(&writer.get_ref()[..], b);
+    }
+
+    #[test]
+    fn vec_seek_past_end() {
+        let mut r = Cursor::new(Vec::new());
+        assert_eq!(r.seek(SeekFrom::Start(10)).unwrap(), 10);
+        assert_eq!(r.write(&[3]).unwrap(), 1);
+    }
+
+    #[test]
+    fn vec_seek_before_0() {
+        let mut r = Cursor::new(Vec::new());
+        assert!(r.seek(SeekFrom::End(-2)).is_err());
+    }
+
+    #[test]
+    #[cfg(target_pointer_width = "32")]
+    fn vec_seek_and_write_past_usize_max() {
+        let mut c = Cursor::new(Vec::new());
+        c.set_position(<usize>::max_value() as u64 + 1);
+        assert!(c.write_all(&[1, 2, 3]).is_err());
+    }
+
+    #[test]
+    fn test_partial_eq() {
+        assert_eq!(Cursor::new(Vec::<u8>::new()), Cursor::new(Vec::<u8>::new()));
+    }
+
+    #[test]
+    fn test_eq() {
+        struct AssertEq<T: Eq>(pub T);
+
+        let _: AssertEq<Cursor<Vec<u8>>> = AssertEq(Cursor::new(Vec::new()));
+    }
+}

src/libcoreio/src/io/error.rs

@@ -0,0 +1,551 @@
+#[cfg(feature="alloc")] use alloc::boxed::Box;
+#[cfg(not(feature="alloc"))] use ::FakeBox as Box;
+use core::convert::Into;
+use core::fmt;
+use core::marker::{Send, Sync};
+use core::option::Option::{self, Some, None};
+use core::result;
+#[cfg(feature="collections")] use collections::string::String;
+#[cfg(not(feature="collections"))] use ::ErrorString as String;
+use core::convert::From;
+
+/// A specialized [`Result`](../result/enum.Result.html) type for I/O
+/// operations.
+///
+/// This type is broadly used across [`std::io`] for any operation which may
+/// produce an error.
+///
+/// This typedef is generally used to avoid writing out [`io::Error`] directly and
+/// is otherwise a direct mapping to [`Result`].
+///
+/// While usual Rust style is to import types directly, aliases of [`Result`]
+/// often are not, to make it easier to distinguish between them. [`Result`] is
+/// generally assumed to be [`std::result::Result`][`Result`], and so users of this alias
+/// will generally use `io::Result` instead of shadowing the prelude's import
+/// of [`std::result::Result`][`Result`].
+///
+/// [`std::io`]: ../io/index.html
+/// [`io::Error`]: ../io/struct.Error.html
+/// [`Result`]: ../result/enum.Result.html
+///
+/// # Examples
+///
+/// A convenience function that bubbles an `io::Result` to its caller:
+///
+/// ```
+/// use std::io;
+///
+/// fn get_string() -> io::Result<String> {
+///     let mut buffer = String::new();
+///
+///     io::stdin().read_line(&mut buffer)?;
+///
+///     Ok(buffer)
+/// }
+/// ```
+pub type Result<T> = result::Result<T, Error>;
+
+/// The error type for I/O operations of the [`Read`], [`Write`], [`Seek`], and
+/// associated traits.
+///
+/// Errors mostly originate from the underlying OS, but custom instances of
+/// `Error` can be created with crafted error messages and a particular value of
+/// [`ErrorKind`].
+///
+/// [`Read`]: ../io/trait.Read.html
+/// [`Write`]: ../io/trait.Write.html
+/// [`Seek`]: ../io/trait.Seek.html
+/// [`ErrorKind`]: enum.ErrorKind.html
+pub struct Error {
+    repr: Repr,
+}
+
+impl fmt::Debug for Error {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        fmt::Debug::fmt(&self.repr, f)
+    }
+}
+
+enum Repr {
+    Os(i32),
+    Simple(ErrorKind),
+    #[cfg(feature="alloc")]
+    Custom(Box<Custom>),
+    #[cfg(not(feature="alloc"))]
+    Custom(Custom),
+}
+
+#[derive(Debug)]
+struct Custom {
+    kind: ErrorKind,
+    error: String,
+}
+
+/// A list specifying general categories of I/O error.
+///
+/// This list is intended to grow over time and it is not recommended to
+/// exhaustively match against it.
+///
+/// It is used with the [`io::Error`] type.
+///
+/// [`io::Error`]: struct.Error.html
+#[derive(Clone, Copy, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
+#[allow(deprecated)]
+#[non_exhaustive]
+pub enum ErrorKind {
+    /// An entity was not found, often a file.
+    NotFound,
+    /// The operation lacked the necessary privileges to complete.
+    PermissionDenied,
+    /// The connection was refused by the remote server.
+    ConnectionRefused,
+    /// The connection was reset by the remote server.
+    ConnectionReset,
+    /// The connection was aborted (terminated) by the remote server.
+    ConnectionAborted,
+    /// The network operation failed because it was not connected yet.
+    NotConnected,
+    /// A socket address could not be bound because the address is already in
+    /// use elsewhere.
+    AddrInUse,
+    /// A nonexistent interface was requested or the requested address was not
+    /// local.
+    AddrNotAvailable,
+    /// The operation failed because a pipe was closed.
+    BrokenPipe,
+    /// An entity already exists, often a file.
+    AlreadyExists,
+    /// The operation needs to block to complete, but the blocking operation was
+    /// requested to not occur.
+    WouldBlock,
+    /// A parameter was incorrect.
+    InvalidInput,
+    /// Data not valid for the operation were encountered.
+    ///
+    /// Unlike [`InvalidInput`], this typically means that the operation
+    /// parameters were valid, however the error was caused by malformed
+    /// input data.
+    ///
+    /// For example, a function that reads a file into a string will error with
+    /// `InvalidData` if the file's contents are not valid UTF-8.
+    ///
+    /// [`InvalidInput`]: #variant.InvalidInput
+    InvalidData,
+    /// The I/O operation's timeout expired, causing it to be canceled.
+    TimedOut,
+    /// An error returned when an operation could not be completed because a
+    /// call to [`write`] returned [`Ok(0)`].
+    ///
+    /// This typically means that an operation could only succeed if it wrote a
+    /// particular number of bytes but only a smaller number of bytes could be
+    /// written.
+    ///
+    /// [`write`]: ../../std/io/trait.Write.html#tymethod.write
+    /// [`Ok(0)`]: ../../std/io/type.Result.html
+    WriteZero,
+    /// This operation was interrupted.
+    ///
+    /// Interrupted operations can typically be retried.
+    Interrupted,
+    /// Any I/O error not part of this list.
+    Other,
+
+    /// An error returned when an operation could not be completed because an
+    /// "end of file" was reached prematurely.
+    ///
+    /// This typically means that an operation could only succeed if it read a
+    /// particular number of bytes but only a smaller number of bytes could be
+    /// read.
+    UnexpectedEof,
+}
+
+impl ErrorKind {
+    pub(crate) fn as_str(&self) -> &'static str {
+        match *self {
+            ErrorKind::NotFound => "entity not found",
+            ErrorKind::PermissionDenied => "permission denied",
+            ErrorKind::ConnectionRefused => "connection refused",
+            ErrorKind::ConnectionReset => "connection reset",
+            ErrorKind::ConnectionAborted => "connection aborted",
+            ErrorKind::NotConnected => "not connected",
+            ErrorKind::AddrInUse => "address in use",
+            ErrorKind::AddrNotAvailable => "address not available",
+            ErrorKind::BrokenPipe => "broken pipe",
+            ErrorKind::AlreadyExists => "entity already exists",
+            ErrorKind::WouldBlock => "operation would block",
+            ErrorKind::InvalidInput => "invalid input parameter",
+            ErrorKind::InvalidData => "invalid data",
+            ErrorKind::TimedOut => "timed out",
+            ErrorKind::WriteZero => "write zero",
+            ErrorKind::Interrupted => "operation interrupted",
+            ErrorKind::Other => "other os error",
+            ErrorKind::UnexpectedEof => "unexpected end of file",
+        }
+    }
+}
+
+/// Intended for use for errors not exposed to the user, where allocating onto
+/// the heap (for normal construction via Error::new) is too costly.
+impl From<ErrorKind> for Error {
+    /// Converts an [`ErrorKind`] into an [`Error`].
+    ///
+    /// This conversion allocates a new error with a simple representation of error kind.
+    ///
+    /// # Examples
+    ///
+    /// ```
+    /// use std::io::{Error, ErrorKind};
+    ///
+    /// let not_found = ErrorKind::NotFound;
+    /// let error = Error::from(not_found);
+    /// assert_eq!("entity not found", format!("{}", error));
+    /// ```
+    ///
+    /// [`ErrorKind`]: ../../std/io/enum.ErrorKind.html
+    /// [`Error`]: ../../std/io/struct.Error.html
+    #[inline]
+    fn from(kind: ErrorKind) -> Error {
+        Error { repr: Repr::Simple(kind) }
+    }
+}
+
+impl Error {
+    /// Creates a new I/O error from a known kind of error as well as an
+    /// arbitrary error payload.
+    ///
+    /// This function is used to generically create I/O errors which do not
+    /// originate from the OS itself. The `error` argument is an arbitrary
+    /// payload which will be contained in this `Error`.
+    ///
+    /// # Examples
+    ///
+    /// ```
+    /// use std::io::{Error, ErrorKind};
+    ///
+    /// // errors can be created from strings
+    /// let custom_error = Error::new(ErrorKind::Other, "oh no!");
+    ///
+    /// // errors can also be created from other errors
+    /// let custom_error2 = Error::new(ErrorKind::Interrupted, custom_error);
+    /// ```
+    pub fn new<E>(kind: ErrorKind, error: E) -> Error
+    where
+        E: Into<String>,
+    {
+        Self::_new(kind, error.into())
+    }
+
+    fn _new(kind: ErrorKind, error: String) -> Error {
+        Error { repr: Repr::Custom(Box::new(Custom { kind, error })) }
+    }
+
+    /// Creates a new instance of an `Error` from a particular OS error code.
+    ///
+    /// # Examples
+    ///
+    /// On Linux:
+    ///
+    /// ```
+    /// # if cfg!(target_os = "linux") {
+    /// use std::io;
+    ///
+    /// let error = io::Error::from_raw_os_error(22);
+    /// assert_eq!(error.kind(), io::ErrorKind::InvalidInput);
+    /// # }
+    /// ```
+    ///
+    /// On Windows:
+    ///
+    /// ```
+    /// # if cfg!(windows) {
+    /// use std::io;
+    ///
+    /// let error = io::Error::from_raw_os_error(10022);
+    /// assert_eq!(error.kind(), io::ErrorKind::InvalidInput);
+    /// # }
+    /// ```
+    pub fn from_raw_os_error(code: i32) -> Error {
+        Error { repr: Repr::Os(code) }
+    }
+
+    /// Returns the OS error that this error represents (if any).
+    ///
+    /// If this `Error` was constructed via `last_os_error` or
+    /// `from_raw_os_error`, then this function will return `Some`, otherwise
+    /// it will return `None`.
+    ///
+    /// # Examples
+    ///
+    /// ```
+    /// use std::io::{Error, ErrorKind};
+    ///
+    /// fn print_os_error(err: &Error) {
+    ///     if let Some(raw_os_err) = err.raw_os_error() {
+    ///         println!("raw OS error: {:?}", raw_os_err);
+    ///     } else {
+    ///         println!("Not an OS error");
+    ///     }
+    /// }
+    ///
+    /// fn main() {
+    ///     // Will print "raw OS error: ...".
+    ///     print_os_error(&Error::last_os_error());
+    ///     // Will print "Not an OS error".
+    ///     print_os_error(&Error::new(ErrorKind::Other, "oh no!"));
+    /// }
+    /// ```
+    pub fn raw_os_error(&self) -> Option<i32> {
+        match self.repr {
+            Repr::Os(i) => Some(i),
+            Repr::Custom(..) => None,
+            Repr::Simple(..) => None,
+        }
+    }
+
+    /// Returns a reference to the inner error wrapped by this error (if any).
+    ///
+    /// If this `Error` was constructed via `new` then this function will
+    /// return `Some`, otherwise it will return `None`.
+    ///
+    /// # Examples
+    ///
+    /// ```
+    /// use std::io::{Error, ErrorKind};
+    ///
+    /// fn print_error(err: &Error) {
+    ///     if let Some(inner_err) = err.get_ref() {
+    ///         println!("Inner error: {:?}", inner_err);
+    ///     } else {
+    ///         println!("No inner error");
+    ///     }
+    /// }
+    ///
+    /// fn main() {
+    ///     // Will print "No inner error".
+    ///     print_error(&Error::last_os_error());
+    ///     // Will print "Inner error: ...".
+    ///     print_error(&Error::new(ErrorKind::Other, "oh no!"));
+    /// }
+    /// ```
+    pub fn get_ref(&self) -> Option<&String> {
+        match self.repr {
+            Repr::Os(..) => None,
+            Repr::Simple(..) => None,
+            Repr::Custom(ref c) => Some(&c.error),
+        }
+    }
+
+    /// Returns a mutable reference to the inner error wrapped by this error
+    /// (if any).
+    ///
+    /// If this `Error` was constructed via `new` then this function will
+    /// return `Some`, otherwise it will return `None`.
+    ///
+    /// # Examples
+    ///
+    /// ```
+    /// use std::io::{Error, ErrorKind};
+    /// use std::{error, fmt};
+    /// use std::fmt::Display;
+    ///
+    /// #[derive(Debug)]
+    /// struct MyError {
+    ///     v: String,
+    /// }
+    ///
+    /// impl MyError {
+    ///     fn new() -> MyError {
+    ///         MyError {
+    ///             v: "oh no!".to_string()
+    ///         }
+    ///     }
+    ///
+    ///     fn change_message(&mut self, new_message: &str) {
+    ///         self.v = new_message.to_string();
+    ///     }
+    /// }
+    ///
+    /// impl error::Error for MyError {}
+    ///
+    /// impl Display for MyError {
+    ///     fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+    ///         write!(f, "MyError: {}", &self.v)
+    ///     }
+    /// }
+    ///
+    /// fn change_error(mut err: Error) -> Error {
+    ///     if let Some(inner_err) = err.get_mut() {
+    ///         inner_err.downcast_mut::<MyError>().unwrap().change_message("I've been changed!");
+    ///     }
+    ///     err
+    /// }
+    ///
+    /// fn print_error(err: &Error) {
+    ///     if let Some(inner_err) = err.get_ref() {
+    ///         println!("Inner error: {}", inner_err);
+    ///     } else {
+    ///         println!("No inner error");
+    ///     }
+    /// }
+    ///
+    /// fn main() {
+    ///     // Will print "No inner error".
+    ///     print_error(&change_error(Error::last_os_error()));
+    ///     // Will print "Inner error: ...".
+    ///     print_error(&change_error(Error::new(ErrorKind::Other, MyError::new())));
+    /// }
+    /// ```
+    pub fn get_mut(&mut self) -> Option<&mut String> {
+        match self.repr {
+            Repr::Os(..) => None,
+            Repr::Simple(..) => None,
+            Repr::Custom(ref mut c) => Some(&mut c.error),
+        }
+    }
+
+    /// Consumes the `Error`, returning its inner error (if any).
+    ///
+    /// If this `Error` was constructed via `new` then this function will
+    /// return `Some`, otherwise it will return `None`.
+    ///
+    /// # Examples
+    ///
+    /// ```
+    /// use std::io::{Error, ErrorKind};
+    ///
+    /// fn print_error(err: Error) {
+    ///     if let Some(inner_err) = err.into_inner() {
+    ///         println!("Inner error: {}", inner_err);
+    ///     } else {
+    ///         println!("No inner error");
+    ///     }
+    /// }
+    ///
+    /// fn main() {
+    ///     // Will print "No inner error".
+    ///     print_error(Error::last_os_error());
+    ///     // Will print "Inner error: ...".
+    ///     print_error(Error::new(ErrorKind::Other, "oh no!"));
+    /// }
+    /// ```
+    pub fn into_inner(self) -> Option<String> {
+        match self.repr {
+            Repr::Os(..) => None,
+            Repr::Simple(..) => None,
+            Repr::Custom(c) => Some(c.error),
+        }
+    }
+
+    /// Returns the corresponding `ErrorKind` for this error.
+    ///
+    /// # Examples
+    ///
+    /// ```
+    /// use std::io::{Error, ErrorKind};
+    ///
+    /// fn print_error(err: Error) {
+    ///     println!("{:?}", err.kind());
+    /// }
+    ///
+    /// fn main() {
+    ///     // Will print "No inner error".
+    ///     print_error(Error::last_os_error());
+    ///     // Will print "Inner error: ...".
+    ///     print_error(Error::new(ErrorKind::AddrInUse, "oh no!"));
+    /// }
+    /// ```
+    pub fn kind(&self) -> ErrorKind {
+        match self.repr {
+            Repr::Os(_code) => ErrorKind::Other,
+            Repr::Custom(ref c) => c.kind,
+            Repr::Simple(kind) => kind,
+        }
+    }
+}
+
+impl fmt::Debug for Repr {
+    fn fmt(&self, fmt: &mut fmt::Formatter<'_>) -> fmt::Result {
+        match *self {
+            Repr::Os(code) => fmt
+                .debug_struct("Os")
+                .field("code", &code)
+                .finish(),
+            Repr::Custom(ref c) => fmt::Debug::fmt(&c, fmt),
+            Repr::Simple(kind) => fmt.debug_tuple("Kind").field(&kind).finish(),
+        }
+    }
+}
+
+impl fmt::Display for Error {
+    fn fmt(&self, fmt: &mut fmt::Formatter<'_>) -> fmt::Result {
+        match self.repr {
+            Repr::Os(code) => {
+                write!(fmt, "os error {}", code)
+            }
+            Repr::Custom(ref c) => c.error.fmt(fmt),
+            Repr::Simple(kind) => write!(fmt, "{}", kind.as_str()),
+        }
+    }
+}
+
+fn _assert_error_is_sync_send() {
+    fn _is_sync_send<T: Sync + Send>() {}
+    _is_sync_send::<Error>();
+}
+
+#[cfg(test)]
+mod test {
+    use super::{Custom, Error, ErrorKind, Repr};
+    use crate::error;
+    use crate::fmt;
+    use crate::sys::decode_error_kind;
+    use crate::sys::os::error_string;
+
+    #[test]
+    fn test_debug_error() {
+        let code = 6;
+        let msg = error_string(code);
+        let kind = decode_error_kind(code);
+        let err = Error {
+            repr: Repr::Custom(box Custom {
+                kind: ErrorKind::InvalidInput,
+                error: box Error { repr: super::Repr::Os(code) },
+            }),
+        };
+        let expected = format!(
+            "Custom {{ \
+             kind: InvalidInput, \
+             error: Os {{ \
+             code: {:?}, \
+             kind: {:?}, \
+             message: {:?} \
+             }} \
+             }}",
+            code, kind, msg
+        );
+        assert_eq!(format!("{:?}", err), expected);
+    }
+
+    #[test]
+    fn test_downcasting() {
+        #[derive(Debug)]
+        struct TestError;
+
+        impl fmt::Display for TestError {
+            fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+                f.write_str("asdf")
+            }
+        }
+
+        impl error::Error for TestError {}
+
+        // we have to call all of these UFCS style right now since method
+        // resolution won't implicitly drop the Send+Sync bounds
+        let mut err = Error::new(ErrorKind::Other, TestError);
+        assert!(err.get_ref().unwrap().is::<TestError>());
+        assert_eq!("asdf", err.get_ref().unwrap().to_string());
+        assert!(err.get_mut().unwrap().is::<TestError>());
+        let extracted = err.into_inner().unwrap();
+        extracted.downcast::<TestError>().unwrap();
+    }
+}

src/libcoreio/src/io/impls.rs

@@ -0,0 +1,378 @@
+use core::cmp;
+use core::fmt;
+use crate::io::{
+    self, Error, ErrorKind, Initializer, Read, Seek, SeekFrom, Write,
+};
+#[cfg(feature = "collections")] use crate::io::BufRead;
+use core::mem;
+
+#[cfg(feature="collections")] 
+use collections::{
+    vec::Vec,
+    string::String,
+};
+#[cfg(feature = "alloc")]
+use alloc::boxed::Box;
+
+// =============================================================================
+// Forwarding implementations
+
+impl<R: Read + ?Sized> Read for &mut R {
+    #[inline]
+    fn read(&mut self, buf: &mut [u8]) -> io::Result<usize> {
+        (**self).read(buf)
+    }
+
+    #[inline]
+    unsafe fn initializer(&self) -> Initializer {
+        (**self).initializer()
+    }
+
+    #[cfg(feature="collections")]
+    #[inline]
+    fn read_to_end(&mut self, buf: &mut Vec<u8>) -> io::Result<usize> {
+        (**self).read_to_end(buf)
+    }
+
+    #[cfg(feature="collections")]
+    #[inline]
+    fn read_to_string(&mut self, buf: &mut String) -> io::Result<usize> {
+        (**self).read_to_string(buf)
+    }
+
+    #[inline]
+    fn read_exact(&mut self, buf: &mut [u8]) -> io::Result<()> {
+        (**self).read_exact(buf)
+    }
+}
+impl<W: Write + ?Sized> Write for &mut W {
+    #[inline]
+    fn write(&mut self, buf: &[u8]) -> io::Result<usize> {
+        (**self).write(buf)
+    }
+
+    #[inline]
+    fn flush(&mut self) -> io::Result<()> {
+        (**self).flush()
+    }
+
+    #[inline]
+    fn write_all(&mut self, buf: &[u8]) -> io::Result<()> {
+        (**self).write_all(buf)
+    }
+
+    #[inline]
+    fn write_fmt(&mut self, fmt: fmt::Arguments<'_>) -> io::Result<()> {
+        (**self).write_fmt(fmt)
+    }
+}
+impl<S: Seek + ?Sized> Seek for &mut S {
+    #[inline]
+    fn seek(&mut self, pos: SeekFrom) -> io::Result<u64> {
+        (**self).seek(pos)
+    }
+}
+#[cfg(feature = "collections")]
+impl<B: BufRead + ?Sized> BufRead for &mut B {
+    #[inline]
+    fn fill_buf(&mut self) -> io::Result<&[u8]> {
+        (**self).fill_buf()
+    }
+
+    #[inline]
+    fn consume(&mut self, amt: usize) {
+        (**self).consume(amt)
+    }
+
+    #[cfg(feature="collections")]
+    #[inline]
+    fn read_until(&mut self, byte: u8, buf: &mut Vec<u8>) -> io::Result<usize> {
+        (**self).read_until(byte, buf)
+    }
+
+    #[cfg(feature="collections")]
+    #[inline]
+    fn read_line(&mut self, buf: &mut String) -> io::Result<usize> {
+        (**self).read_line(buf)
+    }
+}
+
+#[cfg(feature="alloc")]
+#[cfg(feature="collections")]
+impl<R: Read + ?Sized> Read for Box<R> {
+    #[inline]
+    fn read(&mut self, buf: &mut [u8]) -> io::Result<usize> {
+        (**self).read(buf)
+    }
+
+    #[cfg(feature="collections")]
+    #[inline]
+    fn read_to_end(&mut self, buf: &mut Vec<u8>) -> io::Result<usize> {
+        (**self).read_to_end(buf)
+    }
+
+    #[cfg(feature="collections")]
+    #[inline]
+    fn read_to_string(&mut self, buf: &mut String) -> io::Result<usize> {
+        (**self).read_to_string(buf)
+    }
+
+    #[inline]
+    fn read_exact(&mut self, buf: &mut [u8]) -> io::Result<()> {
+        (**self).read_exact(buf)
+    }
+}
+#[cfg(feature="alloc")]
+#[cfg(feature="collections")]
+impl<W: Write + ?Sized> Write for Box<W> {
+    #[inline]
+    fn write(&mut self, buf: &[u8]) -> io::Result<usize> {
+        (**self).write(buf)
+    }
+
+    #[inline]
+    fn flush(&mut self) -> io::Result<()> {
+        (**self).flush()
+    }
+
+    #[inline]
+    fn write_all(&mut self, buf: &[u8]) -> io::Result<()> {
+        (**self).write_all(buf)
+    }
+
+    #[inline]
+    fn write_fmt(&mut self, fmt: fmt::Arguments<'_>) -> io::Result<()> {
+        (**self).write_fmt(fmt)
+    }
+}
+#[cfg(feature="collections")]
+impl<S: Seek + ?Sized> Seek for Box<S> {
+    #[inline]
+    fn seek(&mut self, pos: SeekFrom) -> io::Result<u64> {
+        (**self).seek(pos)
+    }
+}
+#[cfg(feature="collections")]
+impl<B: BufRead + ?Sized> BufRead for Box<B> {
+    #[inline]
+    fn fill_buf(&mut self) -> io::Result<&[u8]> {
+        (**self).fill_buf()
+    }
+
+    #[inline]
+    fn consume(&mut self, amt: usize) {
+        (**self).consume(amt)
+    }
+
+    #[inline]
+    fn read_until(&mut self, byte: u8, buf: &mut Vec<u8>) -> io::Result<usize> {
+        (**self).read_until(byte, buf)
+    }
+
+    #[inline]
+    fn read_line(&mut self, buf: &mut String) -> io::Result<usize> {
+        (**self).read_line(buf)
+    }
+}
+
+// Used by panicking::default_hook
+#[cfg(test)]
+/// This impl is only used by printing logic, so any error returned is always
+/// of kind `Other`, and should be ignored.
+#[cfg(feature="collections")]
+impl Write for Box<dyn (::realstd::io::Write) + Send> {
+    fn write(&mut self, buf: &[u8]) -> io::Result<usize> {
+        (**self).write(buf).map_err(|_| ErrorKind::Other.into())
+    }
+
+    fn flush(&mut self) -> io::Result<()> {
+        (**self).flush().map_err(|_| ErrorKind::Other.into())
+    }
+}
+
+// =============================================================================
+// In-memory buffer implementations
+
+/// Read is implemented for `&[u8]` by copying from the slice.
+///
+/// Note that reading updates the slice to point to the yet unread part.
+/// The slice will be empty when EOF is reached.
+impl Read for &[u8] {
+    #[inline]
+    fn read(&mut self, buf: &mut [u8]) -> io::Result<usize> {
+        let amt = cmp::min(buf.len(), self.len());
+        let (a, b) = self.split_at(amt);
+
+        // First check if the amount of bytes we want to read is small:
+        // `copy_from_slice` will generally expand to a call to `memcpy`, and
+        // for a single byte the overhead is significant.
+        if amt == 1 {
+            buf[0] = a[0];
+        } else {
+            buf[..amt].copy_from_slice(a);
+        }
+
+        *self = b;
+        Ok(amt)
+    }
+
+    #[inline]
+    unsafe fn initializer(&self) -> Initializer {
+        Initializer::nop()
+    }
+
+    #[inline]
+    fn read_exact(&mut self, buf: &mut [u8]) -> io::Result<()> {
+        if buf.len() > self.len() {
+            return Err(Error::new(ErrorKind::UnexpectedEof, "failed to fill whole buffer"));
+        }
+        let (a, b) = self.split_at(buf.len());
+
+        // First check if the amount of bytes we want to read is small:
+        // `copy_from_slice` will generally expand to a call to `memcpy`, and
+        // for a single byte the overhead is significant.
+        if buf.len() == 1 {
+            buf[0] = a[0];
+        } else {
+            buf.copy_from_slice(a);
+        }
+
+        *self = b;
+        Ok(())
+    }
+
+    #[cfg(feature="collections")]
+    #[inline]
+    fn read_to_end(&mut self, buf: &mut Vec<u8>) -> io::Result<usize> {
+        buf.extend_from_slice(*self);
+        let len = self.len();
+        *self = &self[len..];
+        Ok(len)
+    }
+}
+
+#[cfg(feature="collections")]
+impl BufRead for &[u8] {
+    #[inline]
+    fn fill_buf(&mut self) -> io::Result<&[u8]> {
+        Ok(*self)
+    }
+
+    #[inline]
+    fn consume(&mut self, amt: usize) {
+        *self = &self[amt..];
+    }
+}
+
+/// Write is implemented for `&mut [u8]` by copying into the slice, overwriting
+/// its data.
+///
+/// Note that writing updates the slice to point to the yet unwritten part.
+/// The slice will be empty when it has been completely overwritten.
+impl Write for &mut [u8] {
+    #[inline]
+    fn write(&mut self, data: &[u8]) -> io::Result<usize> {
+        let amt = cmp::min(data.len(), self.len());
+        let (a, b) = mem::replace(self, &mut []).split_at_mut(amt);
+        a.copy_from_slice(&data[..amt]);
+        *self = b;
+        Ok(amt)
+    }
+
+    #[inline]
+    fn write_all(&mut self, data: &[u8]) -> io::Result<()> {
+        if self.write(data)? == data.len() {
+            Ok(())
+        } else {
+            Err(Error::new(ErrorKind::WriteZero, "failed to write whole buffer"))
+        }
+    }
+
+    #[inline]
+    fn flush(&mut self) -> io::Result<()> {
+        Ok(())
+    }
+}
+
+/// Write is implemented for `Vec<u8>` by appending to the vector.
+/// The vector will grow as needed.
+#[cfg(feature="collections")]
+impl Write for Vec<u8> {
+    #[inline]
+    fn write(&mut self, buf: &[u8]) -> io::Result<usize> {
+        self.extend_from_slice(buf);
+        Ok(buf.len())
+    }
+
+    #[inline]
+    fn write_all(&mut self, buf: &[u8]) -> io::Result<()> {
+        self.extend_from_slice(buf);
+        Ok(())
+    }
+
+    #[inline]
+    fn flush(&mut self) -> io::Result<()> {
+        Ok(())
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use crate::io::prelude::*;
+
+    #[bench]
+    fn bench_read_slice(b: &mut test::Bencher) {
+        let buf = [5; 1024];
+        let mut dst = [0; 128];
+
+        b.iter(|| {
+            let mut rd = &buf[..];
+            for _ in 0..8 {
+                let _ = rd.read(&mut dst);
+                test::black_box(&dst);
+            }
+        })
+    }
+
+    #[bench]
+    fn bench_write_slice(b: &mut test::Bencher) {
+        let mut buf = [0; 1024];
+        let src = [5; 128];
+
+        b.iter(|| {
+            let mut wr = &mut buf[..];
+            for _ in 0..8 {
+                let _ = wr.write_all(&src);
+                test::black_box(&wr);
+            }
+        })
+    }
+
+    #[bench]
+    fn bench_read_vec(b: &mut test::Bencher) {
+        let buf = vec![5; 1024];
+        let mut dst = [0; 128];
+
+        b.iter(|| {
+            let mut rd = &buf[..];
+            for _ in 0..8 {
+                let _ = rd.read(&mut dst);
+                test::black_box(&dst);
+            }
+        })
+    }
+
+    #[bench]
+    fn bench_write_vec(b: &mut test::Bencher) {
+        let mut buf = Vec::with_capacity(1024);
+        let src = [5; 128];
+
+        b.iter(|| {
+            let mut wr = &mut buf[..];
+            for _ in 0..8 {
+                let _ = wr.write_all(&src);
+                test::black_box(&wr);
+            }
+        })
+    }
+}

src/libcoreio/src/io/prelude.rs

@@ -0,0 +1,13 @@
+//! The I/O Prelude
+//!
+//! The purpose of this module is to alleviate imports of many common I/O traits
+//! by adding a glob import to the top of I/O heavy modules:
+//!
+//! ```
+//! # #![allow(unused_imports)]
+//! use std::io::prelude::*;
+//! ```
+
+
+pub use super::{Read, Seek, Write};
+#[cfg(feature = "collections")] pub use super::BufRead;

src/libcoreio/src/io/util.rs

@@ -0,0 +1,269 @@
+#![allow(missing_copy_implementations)]
+
+use core::fmt;
+use core::mem;
+use crate::io::{self, ErrorKind, Initializer, Read, Write};
+#[cfg(feature = "collections")] use crate::io::BufRead;
+
+/// Copies the entire contents of a reader into a writer.
+///
+/// This function will continuously read data from `reader` and then
+/// write it into `writer` in a streaming fashion until `reader`
+/// returns EOF.
+///
+/// On success, the total number of bytes that were copied from
+/// `reader` to `writer` is returned.
+///
+/// If you’re wanting to copy the contents of one file to another and you’re
+/// working with filesystem paths, see the [`fs::copy`] function.
+///
+/// [`fs::copy`]: ../fs/fn.copy.html
+///
+/// # Errors
+///
+/// This function will return an error immediately if any call to `read` or
+/// `write` returns an error. All instances of `ErrorKind::Interrupted` are
+/// handled by this function and the underlying operation is retried.
+///
+/// # Examples
+///
+/// ```
+/// use std::io;
+///
+/// fn main() -> io::Result<()> {
+///     let mut reader: &[u8] = b"hello";
+///     let mut writer: Vec<u8> = vec![];
+///
+///     io::copy(&mut reader, &mut writer)?;
+///
+///     assert_eq!(&b"hello"[..], &writer[..]);
+///     Ok(())
+/// }
+/// ```
+pub fn copy<R: ?Sized, W: ?Sized>(reader: &mut R, writer: &mut W) -> io::Result<u64>
+where
+    R: Read,
+    W: Write,
+{
+    let mut buf = unsafe {
+        #[allow(deprecated)]
+        let mut buf: [u8; super::DEFAULT_BUF_SIZE] = mem::uninitialized();
+        reader.initializer().initialize(&mut buf);
+        buf
+    };
+
+    let mut written = 0;
+    loop {
+        let len = match reader.read(&mut buf) {
+            Ok(0) => return Ok(written),
+            Ok(len) => len,
+            Err(ref e) if e.kind() == ErrorKind::Interrupted => continue,
+            Err(e) => return Err(e),
+        };
+        writer.write_all(&buf[..len])?;
+        written += len as u64;
+    }
+}
+
+/// A reader which is always at EOF.
+///
+/// This struct is generally created by calling [`empty`]. Please see
+/// the documentation of [`empty()`][`empty`] for more details.
+///
+/// [`empty`]: fn.empty.html
+pub struct Empty {
+    _priv: (),
+}
+
+/// Constructs a new handle to an empty reader.
+///
+/// All reads from the returned reader will return [`Ok`]`(0)`.
+///
+/// [`Ok`]: ../result/enum.Result.html#variant.Ok
+///
+/// # Examples
+///
+/// A slightly sad example of not reading anything into a buffer:
+///
+/// ```
+/// use std::io::{self, Read};
+///
+/// let mut buffer = String::new();
+/// io::empty().read_to_string(&mut buffer).unwrap();
+/// assert!(buffer.is_empty());
+/// ```
+pub fn empty() -> Empty {
+    Empty { _priv: () }
+}
+
+impl Read for Empty {
+    #[inline]
+    fn read(&mut self, _buf: &mut [u8]) -> io::Result<usize> {
+        Ok(0)
+    }
+
+    #[inline]
+    unsafe fn initializer(&self) -> Initializer {
+        Initializer::nop()
+    }
+}
+
+#[cfg(feature="collections")]
+impl BufRead for Empty {
+    #[inline]
+    fn fill_buf(&mut self) -> io::Result<&[u8]> {
+        Ok(&[])
+    }
+    #[inline]
+    fn consume(&mut self, _n: usize) {}
+}
+
+impl fmt::Debug for Empty {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        f.pad("Empty { .. }")
+    }
+}
+
+/// A reader which yields one byte over and over and over and over and over and...
+///
+/// This struct is generally created by calling [`repeat`][repeat]. Please
+/// see the documentation of `repeat()` for more details.
+///
+/// [repeat]: fn.repeat.html
+pub struct Repeat {
+    byte: u8,
+}
+
+/// Creates an instance of a reader that infinitely repeats one byte.
+///
+/// All reads from this reader will succeed by filling the specified buffer with
+/// the given byte.
+///
+/// # Examples
+///
+/// ```
+/// use std::io::{self, Read};
+///
+/// let mut buffer = [0; 3];
+/// io::repeat(0b101).read_exact(&mut buffer).unwrap();
+/// assert_eq!(buffer, [0b101, 0b101, 0b101]);
+/// ```
+pub fn repeat(byte: u8) -> Repeat {
+    Repeat { byte }
+}
+
+impl Read for Repeat {
+    #[inline]
+    fn read(&mut self, buf: &mut [u8]) -> io::Result<usize> {
+        for slot in &mut *buf {
+            *slot = self.byte;
+        }
+        Ok(buf.len())
+    }
+
+    #[inline]
+    unsafe fn initializer(&self) -> Initializer {
+        Initializer::nop()
+    }
+}
+
+impl fmt::Debug for Repeat {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        f.pad("Repeat { .. }")
+    }
+}
+
+/// A writer which will move data into the void.
+///
+/// This struct is generally created by calling [`sink`][sink]. Please
+/// see the documentation of `sink()` for more details.
+///
+/// [sink]: fn.sink.html
+pub struct Sink {
+    _priv: (),
+}
+
+/// Creates an instance of a writer which will successfully consume all data.
+///
+/// All calls to `write` on the returned instance will return `Ok(buf.len())`
+/// and the contents of the buffer will not be inspected.
+///
+/// # Examples
+///
+/// ```rust
+/// use std::io::{self, Write};
+///
+/// let buffer = vec![1, 2, 3, 5, 8];
+/// let num_bytes = io::sink().write(&buffer).unwrap();
+/// assert_eq!(num_bytes, 5);
+/// ```
+pub fn sink() -> Sink {
+    Sink { _priv: () }
+}
+
+impl Write for Sink {
+    #[inline]
+    fn write(&mut self, buf: &[u8]) -> io::Result<usize> {
+        Ok(buf.len())
+    }
+
+    #[inline]
+    fn flush(&mut self) -> io::Result<()> {
+        Ok(())
+    }
+}
+
+impl fmt::Debug for Sink {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        f.pad("Sink { .. }")
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use crate::io::prelude::*;
+    use crate::io::{copy, empty, repeat, sink};
+
+    #[test]
+    fn copy_copies() {
+        let mut r = repeat(0).take(4);
+        let mut w = sink();
+        assert_eq!(copy(&mut r, &mut w).unwrap(), 4);
+
+        let mut r = repeat(0).take(1 << 17);
+        assert_eq!(copy(&mut r as &mut dyn Read, &mut w as &mut dyn Write).unwrap(), 1 << 17);
+    }
+
+    #[test]
+    fn sink_sinks() {
+        let mut s = sink();
+        assert_eq!(s.write(&[]).unwrap(), 0);
+        assert_eq!(s.write(&[0]).unwrap(), 1);
+        assert_eq!(s.write(&[0; 1024]).unwrap(), 1024);
+        assert_eq!(s.by_ref().write(&[0; 1024]).unwrap(), 1024);
+    }
+
+    #[test]
+    fn empty_reads() {
+        let mut e = empty();
+        assert_eq!(e.read(&mut []).unwrap(), 0);
+        assert_eq!(e.read(&mut [0]).unwrap(), 0);
+        assert_eq!(e.read(&mut [0; 1024]).unwrap(), 0);
+        assert_eq!(e.by_ref().read(&mut [0; 1024]).unwrap(), 0);
+    }
+
+    #[test]
+    fn repeat_repeats() {
+        let mut r = repeat(4);
+        let mut b = [0; 1024];
+        assert_eq!(r.read(&mut b).unwrap(), 1024);
+        assert!(b.iter().all(|b| *b == 4));
+    }
+
+    #[test]
+    fn take_some_bytes() {
+        assert_eq!(repeat(4).take(100).bytes().count(), 100);
+        assert_eq!(repeat(4).take(100).bytes().next().unwrap().unwrap(), 4);
+        assert_eq!(repeat(1).take(10).chain(repeat(2).take(10)).bytes().count(), 20);
+    }
+}

src/libcoreio/src/lib.rs

@@ -0,0 +1,51 @@
+//! <p id="core_io-show-docblock"></p>
+//! This is just a listing of the functionality available in this crate. See
+//! the [std documentation](https://doc.rust-lang.org/nightly/std/io/index.html)
+//! for a full description of the functionality.
+#![allow(stable_features,unused_features)]
+#![feature(question_mark,const_fn,copy_from_slice,try_from,str_internals,align_offset,slice_internals)]
+#![cfg_attr(any(feature="alloc",feature="collections"),feature(alloc))]
+#![cfg_attr(pattern_guards,feature(bind_by_move_pattern_guards,nll))]
+#![cfg_attr(non_exhaustive,feature(non_exhaustive))]
+#![cfg_attr(unicode,feature(str_char))]
+#![cfg_attr(unicode,feature(unicode))]
+#![no_std]
+
+#[cfg_attr(feature="collections",macro_use)]
+#[cfg_attr(feature="collections",allow(unused_imports))]
+#[cfg(feature="collections")] extern crate alloc as collections;
+#[cfg(feature="alloc")] extern crate alloc;
+#[cfg(rustc_unicode)]
+extern crate rustc_unicode;
+#[cfg(std_unicode)]
+extern crate std_unicode;
+
+#[cfg(not(feature="collections"))]
+pub type ErrorString = &'static str;
+
+// Provide Box::new wrapper
+#[cfg(not(feature="alloc"))]
+struct FakeBox<T>(core::marker::PhantomData<T>);
+#[cfg(not(feature="alloc"))]
+impl<T> FakeBox<T> {
+	fn new(val: T) -> T {
+		val
+	}
+}
+
+// Needed for older compilers, to ignore vec!/format! macros in tests
+#[cfg(not(feature="collections"))]
+#[allow(unused)]
+macro_rules! vec (
+	( $ elem : expr ; $ n : expr ) => { () };
+	( $ ( $ x : expr ) , * ) => { () };
+	( $ ( $ x : expr , ) * ) => { () };
+);
+#[cfg(not(feature="collections"))]
+#[allow(unused)]
+macro_rules! format {
+	( $ ( $ arg : tt ) * ) => { () };
+}
+
+mod io;
+pub use io::*;

src/libdwarf/Cargo.toml

@@ -1,17 +0,0 @@
-[package]
-# This package is orignally panic_unwind, but is adapted as a dwarf parser
-authors = ["The Rust Project Developers"]
-name = "dwarf"
-version = "0.0.0"
-edition = "2018"
-
-[lib]
-test = false
-bench = false
-doc = false
-
-[dependencies]
-libc = { path = "../libc" }
-unwind = { path = "../libunwind" }
-compiler_builtins = "0.1.0"
-cfg-if = "0.1.8"

src/libdwarf/src/eh.rs

@@ -1,200 +0,0 @@
-//! Parsing of GCC-style Language-Specific Data Area (LSDA)
-//! For details see:
-//!   http://refspecs.linuxfoundation.org/LSB_3.0.0/LSB-PDA/LSB-PDA/ehframechpt.html
-//!   http://mentorembedded.github.io/cxx-abi/exceptions.pdf
-//!   http://www.airs.com/blog/archives/460
-//!   http://www.airs.com/blog/archives/464
-//!
-//! A reference implementation may be found in the GCC source tree
-//! (`<root>/libgcc/unwind-c.c` as of this writing).
-
-#![allow(non_upper_case_globals)]
-#![allow(unused)]
-
-use crate::DwarfReader;
-use core::mem;
-
-pub const DW_EH_PE_omit: u8 = 0xFF;
-pub const DW_EH_PE_absptr: u8 = 0x00;
-
-pub const DW_EH_PE_uleb128: u8 = 0x01;
-pub const DW_EH_PE_udata2: u8 = 0x02;
-pub const DW_EH_PE_udata4: u8 = 0x03;
-pub const DW_EH_PE_udata8: u8 = 0x04;
-pub const DW_EH_PE_sleb128: u8 = 0x09;
-pub const DW_EH_PE_sdata2: u8 = 0x0A;
-pub const DW_EH_PE_sdata4: u8 = 0x0B;
-pub const DW_EH_PE_sdata8: u8 = 0x0C;
-
-pub const DW_EH_PE_pcrel: u8 = 0x10;
-pub const DW_EH_PE_textrel: u8 = 0x20;
-pub const DW_EH_PE_datarel: u8 = 0x30;
-pub const DW_EH_PE_funcrel: u8 = 0x40;
-pub const DW_EH_PE_aligned: u8 = 0x50;
-
-pub const DW_EH_PE_indirect: u8 = 0x80;
-
-#[derive(Copy, Clone)]
-pub struct EHContext<'a> {
-    pub ip: usize,                             // Current instruction pointer
-    pub func_start: usize,                     // Address of the current function
-    pub get_text_start: &'a dyn Fn() -> usize, // Get address of the code section
-    pub get_data_start: &'a dyn Fn() -> usize, // Get address of the data section
-}
-
-pub enum EHAction {
-    None,
-    Cleanup(usize),
-    Catch(usize),
-    Terminate,
-}
-
-pub const USING_SJLJ_EXCEPTIONS: bool = cfg!(all(target_os = "ios", target_arch = "arm"));
-
-pub unsafe fn find_eh_action(
-    lsda: *const u8,
-    context: &EHContext<'_>,
-    foreign_exception: bool,
-) -> Result<EHAction, ()> {
-    if lsda.is_null() {
-        return Ok(EHAction::None);
-    }
-
-    let func_start = context.func_start;
-    let mut reader = DwarfReader::new(lsda);
-
-    let start_encoding = reader.read::<u8>();
-    // base address for landing pad offsets
-    let lpad_base = if start_encoding != DW_EH_PE_omit {
-        read_encoded_pointer(&mut reader, context, start_encoding)?
-    } else {
-        func_start
-    };
-
-    let ttype_encoding = reader.read::<u8>();
-    if ttype_encoding != DW_EH_PE_omit {
-        // Rust doesn't analyze exception types, so we don't care about the type table
-        reader.read_uleb128();
-    }
-
-    let call_site_encoding = reader.read::<u8>();
-    let call_site_table_length = reader.read_uleb128();
-    let action_table = reader.ptr.offset(call_site_table_length as isize);
-    let ip = context.ip;
-
-    if !USING_SJLJ_EXCEPTIONS {
-        while reader.ptr < action_table {
-            let cs_start = read_encoded_pointer(&mut reader, context, call_site_encoding)?;
-            let cs_len = read_encoded_pointer(&mut reader, context, call_site_encoding)?;
-            let cs_lpad = read_encoded_pointer(&mut reader, context, call_site_encoding)?;
-            let cs_action = reader.read_uleb128();
-            // Callsite table is sorted by cs_start, so if we've passed the ip, we
-            // may stop searching.
-            if ip < func_start + cs_start {
-                break;
-            }
-            if ip < func_start + cs_start + cs_len {
-                if cs_lpad == 0 {
-                    return Ok(EHAction::None);
-                } else {
-                    let lpad = lpad_base + cs_lpad;
-                    return Ok(interpret_cs_action(cs_action, lpad, foreign_exception));
-                }
-            }
-        }
-        // Ip is not present in the table.  This should not happen... but it does: issue #35011.
-        // So rather than returning EHAction::Terminate, we do this.
-        Ok(EHAction::None)
-    } else {
-        // SjLj version:
-        // The "IP" is an index into the call-site table, with two exceptions:
-        // -1 means 'no-action', and 0 means 'terminate'.
-        match ip as isize {
-            -1 => return Ok(EHAction::None),
-            0 => return Ok(EHAction::Terminate),
-            _ => (),
-        }
-        let mut idx = ip;
-        loop {
-            let cs_lpad = reader.read_uleb128();
-            let cs_action = reader.read_uleb128();
-            idx -= 1;
-            if idx == 0 {
-                // Can never have null landing pad for sjlj -- that would have
-                // been indicated by a -1 call site index.
-                let lpad = (cs_lpad + 1) as usize;
-                return Ok(interpret_cs_action(cs_action, lpad, foreign_exception));
-            }
-        }
-    }
-}
-
-fn interpret_cs_action(cs_action: u64, lpad: usize, foreign_exception: bool) -> EHAction {
-    if cs_action == 0 {
-        // If cs_action is 0 then this is a cleanup (Drop::drop). We run these
-        // for both Rust panics and foreign exceptions.
-        EHAction::Cleanup(lpad)
-    } else if foreign_exception {
-        // catch_unwind should not catch foreign exceptions, only Rust panics.
-        // Instead just continue unwinding.
-        EHAction::None
-    } else {
-        // Stop unwinding Rust panics at catch_unwind.
-        EHAction::Catch(lpad)
-    }
-}
-
-#[inline]
-fn round_up(unrounded: usize, align: usize) -> Result<usize, ()> {
-    if align.is_power_of_two() { Ok((unrounded + align - 1) & !(align - 1)) } else { Err(()) }
-}
-
-unsafe fn read_encoded_pointer(
-    reader: &mut DwarfReader,
-    context: &EHContext<'_>,
-    encoding: u8,
-) -> Result<usize, ()> {
-    if encoding == DW_EH_PE_omit {
-        return Err(());
-    }
-
-    // DW_EH_PE_aligned implies it's an absolute pointer value
-    if encoding == DW_EH_PE_aligned {
-        reader.ptr = round_up(reader.ptr as usize, mem::size_of::<usize>())? as *const u8;
-        return Ok(reader.read::<usize>());
-    }
-
-    let mut result = match encoding & 0x0F {
-        DW_EH_PE_absptr => reader.read::<usize>(),
-        DW_EH_PE_uleb128 => reader.read_uleb128() as usize,
-        DW_EH_PE_udata2 => reader.read::<u16>() as usize,
-        DW_EH_PE_udata4 => reader.read::<u32>() as usize,
-        DW_EH_PE_udata8 => reader.read::<u64>() as usize,
-        DW_EH_PE_sleb128 => reader.read_sleb128() as usize,
-        DW_EH_PE_sdata2 => reader.read::<i16>() as usize,
-        DW_EH_PE_sdata4 => reader.read::<i32>() as usize,
-        DW_EH_PE_sdata8 => reader.read::<i64>() as usize,
-        _ => return Err(()),
-    };
-
-    result += match encoding & 0x70 {
-        DW_EH_PE_absptr => 0,
-        // relative to address of the encoded value, despite the name
-        DW_EH_PE_pcrel => reader.ptr as usize,
-        DW_EH_PE_funcrel => {
-            if context.func_start == 0 {
-                return Err(());
-            }
-            context.func_start
-        }
-        DW_EH_PE_textrel => (*context.get_text_start)(),
-        DW_EH_PE_datarel => (*context.get_data_start)(),
-        _ => return Err(()),
-    };
-
-    if encoding & DW_EH_PE_indirect != 0 {
-        result = *(result as *const usize);
-    }
-
-    Ok(result)
-}

src/libdwarf/src/lib.rs

@@ -1,74 +0,0 @@
-//! Utilities for parsing DWARF-encoded data streams.
-//! See <http://www.dwarfstd.org>,
-//! DWARF-4 standard, Section 7 - "Data Representation"
-
-#![no_std]
-// This module is used only by x86_64-pc-windows-gnu for now, but we
-// are compiling it everywhere to avoid regressions.
-#![allow(unused)]
-
-#[cfg(test)]
-mod tests;
-
-pub mod eh;
-
-use core::mem;
-
-pub struct DwarfReader {
-    pub ptr: *const u8,
-}
-
-#[repr(C, packed)]
-struct Unaligned<T>(T);
-
-impl DwarfReader {
-    pub fn new(ptr: *const u8) -> DwarfReader {
-        DwarfReader { ptr }
-    }
-
-    // DWARF streams are packed, so e.g., a u32 would not necessarily be aligned
-    // on a 4-byte boundary. This may cause problems on platforms with strict
-    // alignment requirements. By wrapping data in a "packed" struct, we are
-    // telling the backend to generate "misalignment-safe" code.
-    pub unsafe fn read<T: Copy>(&mut self) -> T {
-        let Unaligned(result) = *(self.ptr as *const Unaligned<T>);
-        self.ptr = self.ptr.add(mem::size_of::<T>());
-        result
-    }
-
-    // ULEB128 and SLEB128 encodings are defined in Section 7.6 - "Variable
-    // Length Data".
-    pub unsafe fn read_uleb128(&mut self) -> u64 {
-        let mut shift: usize = 0;
-        let mut result: u64 = 0;
-        let mut byte: u8;
-        loop {
-            byte = self.read::<u8>();
-            result |= ((byte & 0x7F) as u64) << shift;
-            shift += 7;
-            if byte & 0x80 == 0 {
-                break;
-            }
-        }
-        result
-    }
-
-    pub unsafe fn read_sleb128(&mut self) -> i64 {
-        let mut shift: usize = 0;
-        let mut result: u64 = 0;
-        let mut byte: u8;
-        loop {
-            byte = self.read::<u8>();
-            result |= ((byte & 0x7F) as u64) << shift;
-            shift += 7;
-            if byte & 0x80 == 0 {
-                break;
-            }
-        }
-        // sign-extend
-        if shift < 8 * mem::size_of::<u64>() && (byte & 0x40) != 0 {
-            result |= (!0 as u64) << shift;
-        }
-        result as i64
-    }
-}

src/libdwarf/src/tests.rs

@@ -1,19 +0,0 @@
-use super::*;
-
-#[test]
-fn dwarf_reader() {
-    let encoded: &[u8] = &[1, 2, 3, 4, 5, 6, 7, 0xE5, 0x8E, 0x26, 0x9B, 0xF1, 0x59, 0xFF, 0xFF];
-
-    let mut reader = DwarfReader::new(encoded.as_ptr());
-
-    unsafe {
-        assert!(reader.read::<u8>() == u8::to_be(1u8));
-        assert!(reader.read::<u16>() == u16::to_be(0x0203));
-        assert!(reader.read::<u32>() == u32::to_be(0x04050607));
-
-        assert!(reader.read_uleb128() == 624485);
-        assert!(reader.read_sleb128() == -624485);
-
-        assert!(reader.read::<i8>() == i8::to_be(-1));
-    }
-}

src/libdyld/Cargo.toml

@@ -8,4 +8,3 @@ name = "dyld"
 
 [dependencies]
 log = "0.4"
-libcortex_a9 = { git = "https://git.m-labs.hk/M-Labs/zynq-rs.git" }

src/libdyld/src/file.rs

@@ -56,14 +56,6 @@ impl<'a> File<'a> {
         })
     }
 
-    pub fn section_headers<'b>(&'b self) -> impl Iterator<Item = Option<Elf32_Shdr>> + 'b
-    {
-        (0..self.ehdr.e_shnum).map(move |i| {
-            let shdr_off = self.ehdr.e_shoff as usize + mem::size_of::<Elf32_Shdr>() * i as usize;
-            self.read_unaligned::<Elf32_Shdr>(shdr_off)
-        })
-    }
-
     pub fn dyn_header_vaddr(&self) -> Option<Range<usize>> {
         self.program_headers()
             .filter_map(|phdr| phdr)

src/libdyld/src/lib.rs

@@ -2,9 +2,8 @@
 
 extern crate alloc;
 extern crate log;
-extern crate libcortex_a9;
 
-use core::{convert, fmt, ops::Range, str};
+use core::{ops::Range, convert, fmt, str};
 use alloc::string::String;
 use log::{debug, trace};
 use elf::*;
@@ -60,7 +59,6 @@ fn elf_hash(name: &[u8]) -> u32 {
 
 pub struct Library {
     pub image: Image,
-    pub arch: Arch,
     dyn_section: DynamicSection,
     exidx: Range<usize>,
 }
@@ -133,12 +131,7 @@ impl Library {
            .ok_or("cannot read symbol name")?)
     }
 
-    /// Rebind Rela by `name` to a new `addr`
+    pub fn exidx(&self) -> &[usize] {
-    pub fn rebind(&self, name: &[u8], addr: *const ()) -> Result<(), Error> {
-        reloc::rebind(self.arch, self, name, addr as Elf32_Word)
-    }
-
-    pub fn exidx(&self) -> &[u32] {
         self.image.get_ref_slice_unchecked(&self.exidx)
     }
 }
@@ -176,6 +169,7 @@ pub fn load(
         .map_err(|_| "cannot allocate target image")?;
     debug!("ELF target: {} bytes, align to {:X}, allocated at {:08X}", image_size, image_align, image.ptr() as usize);
 
+    let mut exidx = None;
     // LOAD
     for phdr in file.program_headers() {
         let phdr = phdr.ok_or("cannot read program header")?;
@@ -193,21 +187,9 @@ pub fn load(
                     .ok_or("program header requests an out of bounds load (in target)")?;
                 dst.copy_from_slice(src);
             }
-            _ => {}
+            PT_ARM_EXIDX => {
-        }
+                exidx = Some(phdr.p_vaddr as usize..
-    }
+                             (phdr.p_vaddr + phdr.p_filesz) as usize);
-
-    let mut exidx = None;
-    // Obtain EXIDX
-    for shdr in file.section_headers() {
-        let shdr = shdr.ok_or("cannot read section header")?;
-        match shdr.sh_type as usize {
-            SHT_ARM_EXIDX => {
-                let range = shdr.sh_addr as usize..
-                    (shdr.sh_addr + shdr.sh_size) as usize;
-                let _ = image.get(range.clone())
-                    .ok_or("section header specifies EXIDX outside of image (in target)")?;
-                exidx = Some(range);
             }
             _ => {}
         }
@@ -220,10 +202,9 @@ pub fn load(
     debug!("Relocating {} rela, {} rel, {} pltrel",
            dyn_section.rela.len(), dyn_section.rel.len(), dyn_section.pltrel.len());
     let lib = Library {
-        arch,
         image,
         dyn_section,
-        exidx: exidx.ok_or("no EXIDX section")?,
+        exidx: exidx.ok_or("missing EXIDX program header")?,
     };
 
     for rela in lib.rela() {

src/libdyld/src/reloc.rs

@@ -7,10 +7,6 @@ use super::{
     image::Image,
     Library,
 };
-use libcortex_a9::{
-    cache::{dcci_slice, iciallu, bpiall},
-    asm::{dsb, isb},
-};
 
 pub trait Relocatable {
     fn offset(&self) -> usize;
@@ -137,34 +133,3 @@ pub fn relocate<R: Relocatable>(
 
     lib.image.write(rel.offset(), value)
 }
-
-pub fn rebind(
-    arch: Arch, lib: &Library, name: &[u8], value: Elf32_Word
-) -> Result<(), Error> {
-    for rela in lib.pltrel() {
-        let rel_type = RelType::new(arch, rela.type_info())
-            .ok_or("unsupported relocation type")?;
-        match rel_type {
-            RelType::Lookup => {
-                let sym = lib.symtab().get(ELF32_R_SYM(rela.r_info) as usize)
-                    .ok_or("symbol out of bounds of symbol table")?;
-                let sym_name = lib.name_starting_at(sym.st_name as usize)?;
-
-                if sym_name == name {
-                    lib.image.write(rela.offset(), value)?
-                }
-            }
-            // No associated symbols for other relocation types.
-            _ => {}
-        }
-    }
-    // FIXME: the cache maintainance operations may be more than enough,
-    // may cause performance degradation.
-    dcci_slice(lib.image.data);
-    iciallu();
-    bpiall();
-    dsb();
-    isb();
-
-    Ok(())
-}

src/libunwind/Cargo.toml

@@ -1,27 +0,0 @@
-[package]
-authors = ["The Rust Project Developers"]
-name = "unwind"
-version = "0.0.0"
-build = "build.rs"
-edition = "2018"
-include = [
-  '/libunwind/*',
-]
-
-[lib]
-name = "unwind"
-path = "lib.rs"
-test = false
-bench = false
-doc = false
-
-[dependencies]
-compiler_builtins = "0.1.0"
-cfg-if = "0.1.8"
-libc = { path = "../libc" }
-
-[build-dependencies]
-cc = { version = "1.0.1" }
-
-[features]
-llvm-libunwind = []

src/libunwind/backtrace.rs

@@ -1,41 +0,0 @@
-use libc::{c_void, c_int};
-use crate::libunwind as uw;
-
-const UW_REG_SP: c_int = 13;
-
-pub fn backtrace<F>(f: F) -> Result<(), uw::_Unwind_Reason_Code>
-    where F: FnMut(usize) -> ()
-{
-    struct TraceContext<F> {
-        step_fn: F,
-        prev_sp: uw::_Unwind_Word
-    }
-
-    extern fn trace<F>(context: *mut uw::_Unwind_Context, arg: *mut c_void)
-                      -> uw::_Unwind_Reason_Code
-        where F: FnMut(usize) -> ()
-    {
-        unsafe {
-            let trace_context = &mut *(arg as *mut TraceContext<F>);
-
-            // Detect the root of a libfringe thread
-            let cur_sp = uw::_Unwind_GetGR(context, UW_REG_SP);
-            if cur_sp == trace_context.prev_sp {
-                return uw::_URC_END_OF_STACK
-            } else {
-                trace_context.prev_sp = cur_sp;
-            }
-
-            (trace_context.step_fn)(uw::_Unwind_GetIP(context));
-            uw::_URC_NO_REASON
-        }
-    }
-
-    unsafe {
-        let mut trace_context = TraceContext { step_fn: f, prev_sp: 0 };
-        match uw::_Unwind_Backtrace(trace::<F>, &mut trace_context as *mut _ as *mut c_void) {
-            uw::_URC_NO_REASON => Ok(()),
-            err => Err(err)
-        }
-    }
-}

src/libunwind/build.rs

@@ -1,95 +0,0 @@
-fn main() {
-    println!("cargo:rerun-if-changed=build.rs");
-    llvm_libunwind::compile_cpp();
-    llvm_libunwind::compile_c();
-}
-
-mod llvm_libunwind {
-    use std::path::Path;
-
-    fn setup_options(cfg: &mut cc::Build) {
-        cfg.no_default_flags(true);
-        cfg.warnings(false);
-
-        cfg.flag("-nostdlib");
-        cfg.flag("-ffreestanding");
-        cfg.flag("-fno-PIC");
-        cfg.flag("-Isrc");
-        cfg.flag("-isystem../include");
-        cfg.flag("-fno-stack-protector");
-        cfg.flag("--target=armv7-none-eabihf");
-        cfg.flag("-O2");
-
-        cfg.flag("-std=c99");
-        cfg.flag("-fstrict-aliasing");
-        cfg.flag("-fvisibility=hidden");
-        cfg.flag_if_supported("-fvisibility-global-new-delete-hidden");
-        cfg.define("_LIBUNWIND_IS_BAREMETAL", Some("1"));
-        cfg.define("_LIBUNWIND_NO_HEAP", Some("1"));
-        cfg.define("_LIBUNWIND_HAS_NO_THREADS", Some("1"));
-        cfg.define("NDEBUG", Some("1"));
-        // libunwind expects a __LITTLE_ENDIAN__ macro to be set for LE archs, cf. #65765
-        cfg.define("__LITTLE_ENDIAN__", Some("1"));
-        cfg.define("_LIBUNWIND_DISABLE_VISIBILITY_ANNOTATIONS", None);
-        cfg.flag("-U_FORTIFY_SOURCE");
-        cfg.define("_FORTIFY_SOURCE", Some("0"));
-    }
-
-    pub fn compile_c() {
-        let cfg = &mut cc::Build::new();
-        setup_options(cfg);
-        cfg.compiler("clang");
-        cfg.flag("-funwind-tables");
-
-        let unwind_sources = vec![
-            "Unwind-sjlj.c",
-            "UnwindLevel1-gcc-ext.c",
-            "UnwindLevel1.c",
-            "UnwindRegistersRestore.S",
-            "UnwindRegistersSave.S",
-        ];
-
-        let root = Path::new("../llvm_libunwind");
-        cfg.include(root.join("include"));
-        for src in unwind_sources {
-            println!("cargo:rerun-if-changed={}", src);
-            cfg.file(root.join("src").join(src));
-        }
-
-        cfg.compile("unwind_c");
-    }
-
-    /// Compile the libunwind C/C++ source code.
-    pub fn compile_cpp() {
-        let cfg = &mut cc::Build::new();
-        setup_options(cfg);
-        cfg.compiler("clang++");
-        cfg.cpp(true);
-        cfg.cpp_set_stdlib(None);
-
-        // c++ options
-        cfg.flag("-std=c++11");
-        cfg.flag("-nostdinc++");
-        cfg.flag("-fno-exceptions");
-        cfg.flag("-fno-rtti");
-        cfg.flag("-fstrict-aliasing");
-        cfg.flag("-funwind-tables");
-        cfg.flag("-fvisibility=hidden");
-        cfg.flag_if_supported("-fvisibility-global-new-delete-hidden");
-
-        let unwind_sources = vec![
-            "Unwind-EHABI.cpp",
-            "Unwind-seh.cpp",
-            "libunwind.cpp"
-        ];
-
-        let root = Path::new("../llvm_libunwind");
-        cfg.include(root.join("include"));
-        for src in unwind_sources {
-            println!("cargo:rerun-if-changed={}", src);
-            cfg.file(root.join("src").join(src));
-        }
-
-        cfg.compile("unwind_cpp");
-    }
-}

src/libunwind/lib.rs

@@ -1,33 +0,0 @@
-#![no_std]
-#![feature(link_cfg)]
-#![feature(nll)]
-#![feature(unwind_attributes)]
-#![feature(static_nobundle)]
-#![cfg_attr(not(target_env = "msvc"), feature(libc))]
-
-cfg_if::cfg_if! {
-    if #[cfg(target_env = "msvc")] {
-        // no extra unwinder support needed
-    } else if #[cfg(all(target_arch = "wasm32", not(target_os = "emscripten")))] {
-        // no unwinder on the system!
-    } else {
-        mod libunwind;
-        pub use libunwind::*;
-        mod backtrace;
-        pub use backtrace::backtrace;
-    }
-}
-
-#[cfg(target_env = "musl")]
-#[link(name = "unwind", kind = "static", cfg(target_feature = "crt-static"))]
-#[link(name = "gcc_s", cfg(not(target_feature = "crt-static")))]
-extern "C" {}
-
-#[cfg(target_os = "redox")]
-#[link(name = "gcc_eh", kind = "static-nobundle", cfg(target_feature = "crt-static"))]
-#[link(name = "gcc_s", cfg(not(target_feature = "crt-static")))]
-extern "C" {}
-
-#[cfg(all(target_vendor = "fortanix", target_env = "sgx"))]
-#[link(name = "unwind", kind = "static-nobundle")]
-extern "C" {}

src/libunwind/libunwind.rs

@@ -1,285 +0,0 @@
-#![allow(nonstandard_style)]
-
-use libc::{c_int, c_void, uintptr_t};
-
-#[repr(C)]
-#[derive(Debug, Copy, Clone, PartialEq)]
-pub enum _Unwind_Reason_Code {
-    _URC_NO_REASON = 0,
-    _URC_FOREIGN_EXCEPTION_CAUGHT = 1,
-    _URC_FATAL_PHASE2_ERROR = 2,
-    _URC_FATAL_PHASE1_ERROR = 3,
-    _URC_NORMAL_STOP = 4,
-    _URC_END_OF_STACK = 5,
-    _URC_HANDLER_FOUND = 6,
-    _URC_INSTALL_CONTEXT = 7,
-    _URC_CONTINUE_UNWIND = 8,
-    _URC_FAILURE = 9, // used only by ARM EHABI
-}
-pub use _Unwind_Reason_Code::*;
-
-pub type _Unwind_Exception_Class = u64;
-pub type _Unwind_Word = uintptr_t;
-pub type _Unwind_Ptr = uintptr_t;
-pub type _Unwind_Trace_Fn =
-    extern "C" fn(ctx: *mut _Unwind_Context, arg: *mut c_void) -> _Unwind_Reason_Code;
-
-#[cfg(target_arch = "x86")]
-pub const unwinder_private_data_size: usize = 5;
-
-#[cfg(target_arch = "x86_64")]
-pub const unwinder_private_data_size: usize = 6;
-
-#[cfg(all(target_arch = "arm", not(target_os = "ios")))]
-pub const unwinder_private_data_size: usize = 20;
-
-#[cfg(all(target_arch = "arm", target_os = "ios"))]
-pub const unwinder_private_data_size: usize = 5;
-
-#[cfg(target_arch = "aarch64")]
-pub const unwinder_private_data_size: usize = 2;
-
-#[cfg(target_arch = "mips")]
-pub const unwinder_private_data_size: usize = 2;
-
-#[cfg(target_arch = "mips64")]
-pub const unwinder_private_data_size: usize = 2;
-
-#[cfg(any(target_arch = "powerpc", target_arch = "powerpc64"))]
-pub const unwinder_private_data_size: usize = 2;
-
-#[cfg(target_arch = "s390x")]
-pub const unwinder_private_data_size: usize = 2;
-
-#[cfg(target_arch = "sparc64")]
-pub const unwinder_private_data_size: usize = 2;
-
-#[cfg(target_arch = "riscv64")]
-pub const unwinder_private_data_size: usize = 2;
-
-#[cfg(target_os = "emscripten")]
-pub const unwinder_private_data_size: usize = 20;
-
-#[cfg(all(target_arch = "hexagon", target_os = "linux"))]
-pub const unwinder_private_data_size: usize = 35;
-
-#[repr(C)]
-pub struct _Unwind_Exception {
-    pub exception_class: _Unwind_Exception_Class,
-    pub exception_cleanup: _Unwind_Exception_Cleanup_Fn,
-    pub private: [_Unwind_Word; unwinder_private_data_size],
-}
-
-pub enum _Unwind_Context {}
-
-pub type _Unwind_Exception_Cleanup_Fn =
-    extern "C" fn(unwind_code: _Unwind_Reason_Code, exception: *mut _Unwind_Exception);
-#[cfg_attr(
-    all(feature = "llvm-libunwind", any(target_os = "fuchsia", target_os = "linux")),
-    link(name = "unwind", kind = "static")
-)]
-extern "C" {
-    #[unwind(allowed)]
-    pub fn _Unwind_Resume(exception: *mut _Unwind_Exception) -> !;
-    pub fn _Unwind_DeleteException(exception: *mut _Unwind_Exception);
-    pub fn _Unwind_GetLanguageSpecificData(ctx: *mut _Unwind_Context) -> *mut c_void;
-    pub fn _Unwind_GetRegionStart(ctx: *mut _Unwind_Context) -> _Unwind_Ptr;
-    pub fn _Unwind_GetTextRelBase(ctx: *mut _Unwind_Context) -> _Unwind_Ptr;
-    pub fn _Unwind_GetDataRelBase(ctx: *mut _Unwind_Context) -> _Unwind_Ptr;
-}
-
-cfg_if::cfg_if! {
-if #[cfg(all(any(target_os = "ios", target_os = "netbsd", not(target_arch = "arm"))))] {
-    // Not ARM EHABI
-    #[repr(C)]
-    #[derive(Copy, Clone, PartialEq)]
-    pub enum _Unwind_Action {
-        _UA_SEARCH_PHASE = 1,
-        _UA_CLEANUP_PHASE = 2,
-        _UA_HANDLER_FRAME = 4,
-        _UA_FORCE_UNWIND = 8,
-        _UA_END_OF_STACK = 16,
-    }
-    pub use _Unwind_Action::*;
-
-    #[cfg_attr(all(feature = "llvm-libunwind",
-                   any(target_os = "fuchsia", target_os = "linux")),
-               link(name = "unwind", kind = "static"))]
-    extern "C" {
-        pub fn _Unwind_GetGR(ctx: *mut _Unwind_Context, reg_index: c_int) -> _Unwind_Word;
-        pub fn _Unwind_SetGR(ctx: *mut _Unwind_Context, reg_index: c_int, value: _Unwind_Word);
-        pub fn _Unwind_GetIP(ctx: *mut _Unwind_Context) -> _Unwind_Word;
-        pub fn _Unwind_SetIP(ctx: *mut _Unwind_Context, value: _Unwind_Word);
-        pub fn _Unwind_GetIPInfo(ctx: *mut _Unwind_Context, ip_before_insn: *mut c_int)
-                                 -> _Unwind_Word;
-        pub fn _Unwind_FindEnclosingFunction(pc: *mut c_void) -> *mut c_void;
-    }
-
-} else {
-    // ARM EHABI
-    #[repr(C)]
-    #[derive(Copy, Clone, PartialEq)]
-    pub enum _Unwind_State {
-        _US_VIRTUAL_UNWIND_FRAME = 0,
-        _US_UNWIND_FRAME_STARTING = 1,
-        _US_UNWIND_FRAME_RESUME = 2,
-        _US_ACTION_MASK = 3,
-        _US_FORCE_UNWIND = 8,
-        _US_END_OF_STACK = 16,
-    }
-    pub use _Unwind_State::*;
-
-    #[repr(C)]
-    enum _Unwind_VRS_Result {
-        _UVRSR_OK = 0,
-        _UVRSR_NOT_IMPLEMENTED = 1,
-        _UVRSR_FAILED = 2,
-    }
-    #[repr(C)]
-    enum _Unwind_VRS_RegClass {
-        _UVRSC_CORE = 0,
-        _UVRSC_VFP = 1,
-        _UVRSC_FPA = 2,
-        _UVRSC_WMMXD = 3,
-        _UVRSC_WMMXC = 4,
-    }
-    use _Unwind_VRS_RegClass::*;
-    #[repr(C)]
-    enum _Unwind_VRS_DataRepresentation {
-        _UVRSD_UINT32 = 0,
-        _UVRSD_VFPX = 1,
-        _UVRSD_FPAX = 2,
-        _UVRSD_UINT64 = 3,
-        _UVRSD_FLOAT = 4,
-        _UVRSD_DOUBLE = 5,
-    }
-    use _Unwind_VRS_DataRepresentation::*;
-
-    pub const UNWIND_POINTER_REG: c_int = 12;
-    pub const UNWIND_SP_REG: c_int = 13;
-    pub const UNWIND_IP_REG: c_int = 15;
-
-    #[cfg_attr(all(feature = "llvm-libunwind",
-                   any(target_os = "fuchsia", target_os = "linux")),
-               link(name = "unwind", kind = "static"))]
-    extern "C" {
-        fn _Unwind_VRS_Get(ctx: *mut _Unwind_Context,
-                           regclass: _Unwind_VRS_RegClass,
-                           regno: _Unwind_Word,
-                           repr: _Unwind_VRS_DataRepresentation,
-                           data: *mut c_void)
-                           -> _Unwind_VRS_Result;
-
-        fn _Unwind_VRS_Set(ctx: *mut _Unwind_Context,
-                           regclass: _Unwind_VRS_RegClass,
-                           regno: _Unwind_Word,
-                           repr: _Unwind_VRS_DataRepresentation,
-                           data: *mut c_void)
-                           -> _Unwind_VRS_Result;
-    }
-
-    // On Android or ARM/Linux, these are implemented as macros:
-
-    pub unsafe fn _Unwind_GetGR(ctx: *mut _Unwind_Context, reg_index: c_int) -> _Unwind_Word {
-        let mut val: _Unwind_Word = 0;
-        _Unwind_VRS_Get(ctx, _UVRSC_CORE, reg_index as _Unwind_Word, _UVRSD_UINT32,
-                        &mut val as *mut _ as *mut c_void);
-        val
-    }
-
-    pub unsafe fn _Unwind_SetGR(ctx: *mut _Unwind_Context, reg_index: c_int, value: _Unwind_Word) {
-        let mut value = value;
-        _Unwind_VRS_Set(ctx, _UVRSC_CORE, reg_index as _Unwind_Word, _UVRSD_UINT32,
-                        &mut value as *mut _ as *mut c_void);
-    }
-
-    pub unsafe fn _Unwind_GetIP(ctx: *mut _Unwind_Context)
-                                -> _Unwind_Word {
-        let val = _Unwind_GetGR(ctx, UNWIND_IP_REG);
-        (val & !1) as _Unwind_Word
-    }
-
-    pub unsafe fn _Unwind_SetIP(ctx: *mut _Unwind_Context,
-                                value: _Unwind_Word) {
-        // Propagate thumb bit to instruction pointer
-        let thumb_state = _Unwind_GetGR(ctx, UNWIND_IP_REG) & 1;
-        let value = value | thumb_state;
-        _Unwind_SetGR(ctx, UNWIND_IP_REG, value);
-    }
-
-    pub unsafe fn _Unwind_GetIPInfo(ctx: *mut _Unwind_Context,
-                                    ip_before_insn: *mut c_int)
-                                    -> _Unwind_Word {
-        *ip_before_insn = 0;
-        _Unwind_GetIP(ctx)
-    }
-
-    // This function also doesn't exist on Android or ARM/Linux, so make it a no-op
-    pub unsafe fn _Unwind_FindEnclosingFunction(pc: *mut c_void) -> *mut c_void {
-        pc
-    }
-}
-} // cfg_if!
-
-cfg_if::cfg_if! {
-if #[cfg(not(all(target_os = "ios", target_arch = "arm")))] {
-    // Not 32-bit iOS
-    #[cfg_attr(all(feature = "llvm-libunwind",
-                   any(target_os = "fuchsia", target_os = "linux")),
-               link(name = "unwind", kind = "static"))]
-    extern "C" {
-        #[unwind(allowed)]
-        pub fn _Unwind_RaiseException(exception: *mut _Unwind_Exception) -> _Unwind_Reason_Code;
-        pub fn _Unwind_Backtrace(trace: _Unwind_Trace_Fn,
-                                 trace_argument: *mut c_void)
-                                 -> _Unwind_Reason_Code;
-    }
-} else {
-    // 32-bit iOS uses SjLj and does not provide _Unwind_Backtrace()
-    #[cfg_attr(all(feature = "llvm-libunwind",
-                   any(target_os = "fuchsia", target_os = "linux")),
-               link(name = "unwind", kind = "static"))]
-    extern "C" {
-        #[unwind(allowed)]
-        pub fn _Unwind_SjLj_RaiseException(e: *mut _Unwind_Exception) -> _Unwind_Reason_Code;
-    }
-
-    #[inline]
-    pub unsafe fn _Unwind_RaiseException(exc: *mut _Unwind_Exception) -> _Unwind_Reason_Code {
-        _Unwind_SjLj_RaiseException(exc)
-    }
-}
-} // cfg_if!
-
-cfg_if::cfg_if! {
-if #[cfg(all(windows, target_arch = "x86_64", target_env = "gnu"))] {
-    // We declare these as opaque types. This is fine since you just need to
-    // pass them to _GCC_specific_handler and forget about them.
-    pub enum EXCEPTION_RECORD {}
-    pub type LPVOID = *mut c_void;
-    pub enum CONTEXT {}
-    pub enum DISPATCHER_CONTEXT {}
-    pub type EXCEPTION_DISPOSITION = c_int;
-    type PersonalityFn = unsafe extern "C" fn(version: c_int,
-                                              actions: _Unwind_Action,
-                                              exception_class: _Unwind_Exception_Class,
-                                              exception_object: *mut _Unwind_Exception,
-                                              context: *mut _Unwind_Context)
-                                              -> _Unwind_Reason_Code;
-
-    extern "C" {
-        pub fn _GCC_specific_handler(exceptionRecord: *mut EXCEPTION_RECORD,
-                                establisherFrame: LPVOID,
-                                contextRecord: *mut CONTEXT,
-                                dispatcherContext: *mut DISPATCHER_CONTEXT,
-                                personality: PersonalityFn)
-                                -> EXCEPTION_DISPOSITION;
-    }
-}
-} // cfg_if!
-
-#[no_mangle]
-extern fn abort() {
-    panic!("Abort!");
-}
-

src/llvm_libunwind/.arcconfig

@@ -1,4 +0,0 @@
-{
-  "repository.callsign" : "UNW",
-  "conduit_uri" : "https://reviews.llvm.org/"
-}

src/llvm_libunwind/.clang-format

@@ -1,2 +0,0 @@
-BasedOnStyle: LLVM
-