gen-headers: Generate assertions of layout from witx (#149)

* use pch/layout branch for witx; generate assertions of layout

* address review comments, add asserts for handle

* change wasm32 support comment to a preprocessor error

* expose `to_c_header` in wasi-headers crate for use in external test harness

* main.rs: inputs and output arguments are optional

so that generate-libc command works

* regen header

Author: pchickey

libc-bottom-half/headers/public/wasi/api.h

@@ -1,7 +1,7 @@
 use heck::ShoutySnakeCase;
 use witx::*;
 
-pub(crate) fn to_c_header(doc: &Document, inputs_str: &str) -> String {
+pub fn to_c_header(doc: &Document, inputs_str: &str) -> String {
     let mut ret = String::new();
 
     ret.push_str(&format!(
@@ -27,6 +27,10 @@ pub(crate) fn to_c_header(doc: &Document, inputs_str: &str) -> String {
 #error <wasi/api.h> is only supported on WASI platforms.
 #endif
 
+#ifndef __wasm32__
+#error <wasi/api.h> only supports wasm32; doesn't yet support wasm64
+#endif
+
 #include <stddef.h>
 #include <stdint.h>
 
@@ -38,6 +42,7 @@ _Static_assert(_Alignof(int32_t) == 4, "non-wasi data layout");
 _Static_assert(_Alignof(uint32_t) == 4, "non-wasi data layout");
 _Static_assert(_Alignof(int64_t) == 8, "non-wasi data layout");
 _Static_assert(_Alignof(uint64_t) == 8, "non-wasi data layout");
+_Static_assert(_Alignof(void*) == 4, "non-wasi data layout");
 
 #ifdef __cplusplus
 extern "C" {{
@@ -117,6 +122,19 @@ fn print_alias(ret: &mut String, name: &Id, dest: &TypeRef) {
                 ));
             }
             ret.push_str("\n");
+
+            ret.push_str(&format!(
+                "_Static_assert(sizeof(__wasi_{}_t) == {}, \"witx calculated size\");\n",
+                ident_name(name),
+                dest.mem_size_align().size
+            ));
+            ret.push_str(&format!(
+                "_Static_assert(_Alignof(__wasi_{}_t) == {}, \"witx calculated align\");\n",
+                ident_name(name),
+                dest.mem_size_align().align
+            ));
+
+            ret.push_str("\n");
         }
     }
 }
@@ -146,6 +164,19 @@ fn print_enum(ret: &mut String, name: &Id, e: &EnumDatatype) {
         ));
         ret.push_str("\n");
     }
+
+    ret.push_str(&format!(
+        "_Static_assert(sizeof(__wasi_{}_t) == {}, \"witx calculated size\");\n",
+        ident_name(name),
+        e.repr.mem_size()
+    ));
+    ret.push_str(&format!(
+        "_Static_assert(_Alignof(__wasi_{}_t) == {}, \"witx calculated align\");\n",
+        ident_name(name),
+        e.repr.mem_align()
+    ));
+
+    ret.push_str("\n");
 }
 
 fn print_int(ret: &mut String, name: &Id, i: &IntDatatype) {
@@ -213,6 +244,19 @@ fn print_flags(ret: &mut String, name: &Id, f: &FlagsDatatype) {
         ));
         ret.push_str("\n");
     }
+
+    ret.push_str(&format!(
+        "_Static_assert(sizeof(__wasi_{}_t) == {}, \"witx calculated size\");\n",
+        ident_name(name),
+        f.repr.mem_size(),
+    ));
+    ret.push_str(&format!(
+        "_Static_assert(_Alignof(__wasi_{}_t) == {}, \"witx calculated align\");\n",
+        ident_name(name),
+        f.repr.mem_align(),
+    ));
+
+    ret.push_str("\n");
 }
 
 fn print_struct(ret: &mut String, name: &Id, s: &StructDatatype) {
@@ -239,6 +283,28 @@ fn print_struct(ret: &mut String, name: &Id, s: &StructDatatype) {
 
     ret.push_str(&format!("}} __wasi_{}_t;\n", ident_name(name)));
     ret.push_str("\n");
+
+    ret.push_str(&format!(
+        "_Static_assert(sizeof(__wasi_{}_t) == {}, \"witx calculated size\");\n",
+        ident_name(name),
+        s.mem_size()
+    ));
+    ret.push_str(&format!(
+        "_Static_assert(_Alignof(__wasi_{}_t) == {}, \"witx calculated align\");\n",
+        ident_name(name),
+        s.mem_align()
+    ));
+
+    for layout in s.member_layout() {
+        ret.push_str(&format!(
+            "_Static_assert(offsetof(__wasi_{}_t, {}) == {}, \"witx calculated offset\");\n",
+            ident_name(name),
+            ident_name(&layout.member.name),
+            layout.offset
+        ));
+    }
+
+    ret.push_str("\n");
 }
 
 fn print_union(ret: &mut String, name: &Id, u: &UnionDatatype) {
@@ -262,10 +328,36 @@ fn print_union(ret: &mut String, name: &Id, u: &UnionDatatype) {
 
     ret.push_str(&format!("}} __wasi_{}_t;\n", ident_name(name)));
     ret.push_str("\n");
+
+    ret.push_str(&format!(
+        "_Static_assert(sizeof(__wasi_{}_t) == {}, \"witx calculated size\");\n",
+        ident_name(name),
+        u.mem_size()
+    ));
+    ret.push_str(&format!(
+        "_Static_assert(_Alignof(__wasi_{}_t) == {}, \"witx calculated align\");\n",
+        ident_name(name),
+        u.mem_align()
+    ));
+
+    ret.push_str("\n");
 }
 
-fn print_handle(ret: &mut String, name: &Id, _h: &HandleDatatype) {
+fn print_handle(ret: &mut String, name: &Id, h: &HandleDatatype) {
     ret.push_str(&format!("typedef int __wasi_{}_t;", ident_name(name)));
+
+    ret.push_str(&format!(
+        "_Static_assert(sizeof(__wasi_{}_t) == {}, \"witx calculated size\");\n",
+        ident_name(name),
+        h.mem_size()
+    ));
+    ret.push_str(&format!(
+        "_Static_assert(_Alignof(__wasi_{}_t) == {}, \"witx calculated align\");\n",
+        ident_name(name),
+        h.mem_align()
+    ));
+
+    ret.push_str("\n");
 }
 
 fn print_module(ret: &mut String, m: &Module) {

tools/wasi-headers/WASI

@@ -1,7 +1,7 @@
 mod c_header;
 
 use anyhow::{anyhow, Result};
-use c_header::to_c_header;
+pub use c_header::to_c_header;
 use std::fs;
 use std::io;
 use std::path::PathBuf;

tools/wasi-headers/src/c_header.rs

@@ -26,13 +26,13 @@ impl GenerateCommand {
 
 fn main() -> Result<()> {
     let matches = app_from_crate!()
-        .arg(Arg::with_name("inputs").required(true).multiple(true))
+        .arg(Arg::with_name("inputs").required(false).multiple(true))
         .arg(
             Arg::with_name("output")
                 .short("o")
                 .long("output")
                 .takes_value(true)
-                .required(true),
+                .required(false),
         )
         .subcommand(
             SubCommand::with_name("generate-libc")