Ave1

Unfortunately, I've added a more files to the ZFP runtime. These files are all needed to support the full Ada syntax;

Assert

The mechanism behind the Assert pragma depends on the Ada.Assertions module (implemented in the files adainclude/a-assert.adb and adainclude/a-assert.adb), see also the LRM. This module was added but no visible effect was found when compiling an Ada module with an assert pragma. The GNAT compiler instead uses the Raise_Assert_Failure procedure (in file adainclude/s-assert.adb).

Aggregates

Some operations on arrays will apply for every element of an array. For example clearing an array with something like A := (others => 0);. The operations are called aggregate and depend on memcpy and memcmp. These functions are not available when compiling without any C library. The GNAT source contains Ada implementations for both and I've included memcmp function (in file adainclude/s-memcom.adb). Such a version is portable but not really optimal, so for memcpy I've included the code from the MUSL C library. So far I've only used memcmp, so more testing is needed.

To use this code, download the patch and signature;

• The patch: zfp_4_assert.vpatch.
• The signature: zfp_4_assert.vpatch.ave1.sig.

And then press and play.

An Ada runtime library is used to provide a standard interface to different operating systems and hardware. Already two different ways of compilation (1) based on the C library (2) based on assembly code, is supported in the ZFP library. Both versions can be had by pressing a different node of the v-tree. Although this works, it all becomes complicated when I want to add the same file to both systems and have to maintain multiple branches. Also, I want to a add a version of the library with no OS support and one with 64-bit arm support and probably MIPS and so on and so forth.

I needed to do a major overhaul of the code to support different platforms. An option was added to the gprbuild project file and with this option different source directories are selected to compile the library. All the sources have been distributed over different directories, one directory adainclude for generic (non-platform specific) code and multiple directories under the platform directory for all those files that are different per system. Now that all the source files are in different directories, the only way the runtime can be used is once it is installed¹.

To use this new code, download the patch and signature;

• The patch: zfp_3_platform.vpatch.
• The signature: zfp_3_platform.vpatch.ave1.sig.

After pressing, you'll need to do the following magic commands in the zfp directory²;

make clean MODE=x86_64-asm

make MODE=x86_64-asm

make install MODE=x86_64-asm PREFIX=prefix-asm

To check;

cd examples

make clean

make RTS=../prefix-asm

This will build the assembly based gnat library, for the C based do in the zfp directory;

make clean

make MODE=x86_64-c

make install MODE=x86_64-asm PREFIX=prefix-c

Again, to check

cd examples

make clean

make RTS=../prefix-c

Once built and installed into a prefix directory the default GNAT, the C and asm library can all be used to build the examples. The only thing to be set is the runtime directory with the RTS environment variable.

1. At installation time the source files will nicely be put into the target adainclude directory with the gprinstall command [↩]
2. make is necessary, the gprbuild is fine for building Ada libraries and executables but when it comes to a simple rule to copy a file to a new name (so that gprinstall can pick it up and install that file) you can forget about it. [↩]

No new code in this installment. Instead, a regrind of all 3 patches, after a helpful suggestion to do so by Diana Coman . With this regrind, I updated the patches to follow the current thinking in vpatch management; the whole package under a common subdirectory, addition of a manifest and all files hashed with Keccak.

• The patches:
  - zfp_genesis.vpatch.
  - zfp_1_examples.vpatch.
  - zfp_2_noc.vpatch.
• The signatures:
  - zfp_genesis.vpatch.ave1.sig.
  - zfp_1_examples.vpatch.ave1.sig.
  - zfp_2_noc.vpatch.ave1.sig.

You can download and press the files with

v.pl init http://ave1.org/code/zfp

but you will have to comment out the hash checking code.

"Libc gotta go."

—Stanislav Datskovskiy

And it will. In an, at this moment, unknown amount of steps the C library can be ripped out from the Ada Runtime library and be replaced with Ada and assembly code. In the first step, all C calls need to be replaced with Ada code and possibly some assembly to perform system calls to the Linux kernel. The second step is then to replace the C library specific start-up code with code for Ada.

I start with the previous version of a minimal ZFP library for Linux. This library uses only two calls to the C library, one to output characters and the other to exit the code. Both are replaced with a direct system call¹. The second change is to include a file with startup code². The resulting code is published in the following vpatch (with signature).

• The patch: zfp_2_noc.vpatch.
• A signature: zfp_2_noc.vpatch.ave1.sig.

Combine this patch with those from the previous installment, press and build it. Building the code needs to be done with the Makefile³.

<<create a directory and put a .wot directory in it with at least my key>>

v.pl init http://ave1.org/code/zfp

v.pl p a zfp_2_noc.vpatch

cd a

make

cd examples

make

All system calls can be found in the adainclude/s-syscal.adb file. The Write function (used for outputting characters) is implemented as a single assembly statement syscall with the parameter list specified to fill the right processor registers. The function starts with a conversion from characters to bytes⁴ and ends with a check of the return values. After a completed system call the 'RAX' register will be filled with a return code. If an error occurred during execution of the system call, the register will contain the error code as a negative number (always between -1 and -4096). If the execution was successful the register will contain 0 or any other 64bit number outside of the range -1 to -4096.

function Write (fd : in Int; S : in String; E : out ErrorCode) return Int is
    type byte is mod 2**8;
    B : array (S'Range) of byte;
    R : Int := 0;
 begin
    for I in S'Range loop
       B (I) := Character'Pos (S (I));
    end loop;
    Asm
      ("syscall",
       Outputs => (Int'Asm_Output ("=a", R)),
       Inputs  =>
         (Int'Asm_Input ("a", SYSCALL_WRITE),
          Int'Asm_Input ("D", fd),
          System.Address'Asm_Input ("S", B'Address),
          Int'Asm_Input ("d", B'Length)),
       Volatile => True);
    if R < 0 and R >= -(2**12) then
       E := ErrorCode'Val (-R);
       R := -1;
    else
       E := OK;
    end if;
    return R;
 end Write;

The a-textio.adb and last_chance_handler.adb files have been updated to use the system calls instead of the C library. The s-maccod.ads was added from the GNAT runtime library to support the inline assembly code. The other addition is the startup.S file. In it simplest working form it just needs to contain one definition of a global (_start), a call to a main function and a syscall to exit the code;

.global _start

_start:
  call main

  /* exit code */
  mov $60, %rax
  mov $0, %rdi
  syscall

The version in the patch also stores the argument count and a pointer to the argument array in two globals. Both globals are unused for now but will be needed for future parsing of any command line arguments.

The final noteworthy change is the inclusion of a runtime.xml file. The gprbuild command will use this file to set flags for all projects that are build with the runtime library. For reasons , this file is written as an xml file containing gprbuild project statements;

<?xml version="1.0" ?>

<gprconfig>
  <configuration>
   <config>
   package Linker is
      for Required_Switches use Linker'Required_Switches &amp;
        ("${RUNTIME_DIR(ada)}/adalib/libgnat.a") &amp;
        ("-nostdlib", "-nodefaultlibs", "-lgcc");

      for Required_Switches use Linker'Required_Switches &amp;
          ("${RUNTIME_DIR(ada)}/adalib/start.o");
   end Linker;

   package Binder is
      for Required_Switches ("Ada") use Binder'Required_Switches ("Ada") &amp;
       ("-nostdlib") ;
   end Binder;
   </config>
  </configuration>
</gprconfig>

The linker flags are set so that no standard C library or startup code is included in the resulting binary. As we are then lacking the default startup code, an extra line is added to include the start.o code with every compile.

In the end, the fun part, a working binary. The hello world example from the previous installment can be built and it's size inspected. It is now at 2.6k (down from 54k) on my computer⁵.

In the final end, I will include another reference to AdaCore's configurable runtime documentation. The GNAT documentation has been very helpful for learning the GNAT system and developing this library.

1. The main difficulty in doing so is to learn how the Linux system calls work and get a better understanding of the inline assembly statements. Stans' demo.asm posted in the logs proved very helpful for this process [↩]
2. This file is now written in assembly, although (upon reflection) it should be possible to rewrite it in Ada [↩]
3. I did not find a method to compile one separate file into an object file with gprbuild [↩]
4. Which in practice will be a copy operation [↩]
5. Ofcourse, this minimal library is too minimal. In some cases (for example when a string is concatenated) the compiler will generate memcpy or memset calls. We need to provide replacement Ada functions for each. This is not difficult as the ada 2017 code contains pure Ada versions for all of these. [↩]