add ability to name all symbols in the C API

Author: redianthus

src/lang_c/libowi/include/owi.h

@@ -9,20 +9,28 @@ extern "C"
 #endif
 
 __attribute__((import_module("owi"), import_name("i32_symbol")))  int32_t  owi_int32(void);
+int32_t owi_named_int32(const char* name);
 __attribute__((import_module("owi"), import_name("i32_symbol"))) uint32_t owi_uint32(void);
+uint32_t owi_named_uint32(const char* name);
 __attribute__((import_module("owi"), import_name("i64_symbol")))  int64_t  owi_int64(void);
+int64_t owi_named_int64(const char* name);
 __attribute__((import_module("owi"), import_name("i64_symbol"))) uint64_t owi_uint64(void);
+uint64_t owi_named_uint64(const char* name);
 
 #ifndef __FRAMAC__
 __int128 owi_int128(void);
+__int128 owi_named_int128(const char* name);
 unsigned __int128 owi_uint128(void);
+unsigned __int128 owi_named_uint128(const char* name);
 #endif
 
 _Static_assert(sizeof(float) == 4, "Unsupported float size. Please open an issue.");
 __attribute__((import_module("owi"), import_name("f32_symbol"))) float owi_float(void);
+float owi_named_float(const char* name);
 
 _Static_assert(sizeof(double) == 8, "Unsupported double size. Please open an issue.");
 __attribute__((import_module("owi"), import_name("f64_symbol"))) double owi_double(void);
+double owi_named_double(const char* name);
 
 // TODO
 // long double owi_long_double(void);
@@ -34,19 +42,36 @@ __attribute__((import_module("owi"), import_name("f64_symbol"))) double owi_doub
   _Bool
 #endif
      owi_bool(void);
+#ifdef __cplusplus
+  bool
+#else
+  _Bool
+#endif
+     owi_named_bool(const char* name);
 char owi_char(void);
+char owi_named_char(const char* name);
 unsigned char owi_unsigned_char(void);
+unsigned char owi_named_unsigned_char(const char* name);
 short owi_short(void);
+short owi_named_short(const char* name);
 unsigned short owi_unsigned_short(void);
+unsigned short owi_named_unsigned_short(const char* name);
 int owi_int(void);
+int owi_named_int(const char* name);
 unsigned int owi_unsigned_int(void);
+unsigned int owi_named_unsigned_int(const char* name);
 long owi_long(void);
+long owi_named_long(const char* name);
 unsigned long owi_unsigned_long(void);
+unsigned long owi_named_unsigned_long(const char* name);
 long long owi_long_long(void);
+long long owi_named_long_long(const char* name);
 unsigned long long owi_unsigned_long_long(void);
+unsigned long long owi_named_unsigned_long_long(const char* name);
 
 // TODO: improve this
 __attribute__((import_module("owi"), import_name("range_symbol"))) int owi_range(int lo, int hi);
+int owi_named_range(const char* name, int lo, int hi);
 
 __attribute__((import_module("owi"), import_name("alloc"))) void *owi_malloc(void *, unsigned int);
 __attribute__((import_module("owi"), import_name("print_char"))) void owi_print_char(int);
@@ -57,11 +82,12 @@ __attribute__((import_module("owi"), import_name("cov_label_set"))) void owi_lab
 #ifdef __OWI_INTERNALS
 
 __attribute__((import_module("owi"), import_name("invisible_bool_symbol"))) int owi_invisible_bool(void);
-__attribute__((import_module("owi"), import_name("open_scope"))) void owi_open_scope(const char *name);
-__attribute__((import_module("owi"), import_name("close_scope"))) void owi_close_scope(void);
 
 #endif
 
+__attribute__((import_module("owi"), import_name("open_scope"))) void owi_open_scope(const char *name);
+__attribute__((import_module("owi"), import_name("close_scope"))) void owi_close_scope(void);
+
 __attribute__((import_module("owi"), import_name("assume"))) void owi_assume(int);
 __attribute__((import_module("owi"), import_name("assert"))) void owi_assert(int);
 // TODO: do we need these two ? we already have abort and exit in stdlib that are exactly the same

src/lang_c/libowi/src/owi.c

@@ -22,51 +22,75 @@
                        : (T)(owi_uint64());                                    \
   })
 
+#define OWI_NAMED(type, name)                                                  \
+  type owi_named_##name(const char *n) {                                       \
+    owi_open_scope(n);                                                         \
+    type sym = owi_##name();                                                   \
+    owi_close_scope();                                                         \
+    return sym;                                                                \
+  }
+
+OWI_NAMED(int32_t, int32);
+OWI_NAMED(uint32_t, uint32);
+OWI_NAMED(int64_t, int64);
+OWI_NAMED(uint64_t, uint64);
+OWI_NAMED(float, float);
+OWI_NAMED(double, double);
+int owi_range_named(const char *name, int lo, int hi) {
+  owi_open_scope(name);
+  int sym = owi_range(lo, hi);
+  owi_close_scope();
+  return sym;
+};
+
 #ifdef __cplusplus
-bool
-#else
-_Bool
-#endif
-  owi_bool(void) {
-  return magic_size_unsigned(
-#ifdef __cplusplus
-      bool
+#define OWI_BOOL bool
 #else
-      _Bool
+#define OWI_BOOL _Bool
 #endif
-  );
-}
+
+OWI_BOOL owi_bool(void) { return magic_size_unsigned(OWI_BOOL); }
+OWI_NAMED(OWI_BOOL, bool)
 
 char owi_char(void) { return magic_size_signed(char); }
+OWI_NAMED(char, char)
 
 unsigned char owi_unsigned_char(void) {
   return magic_size_unsigned(unsigned char);
 }
+OWI_NAMED(unsigned char, unsigned_char)
 
 short owi_short(void) { return magic_size_signed(short); }
+OWI_NAMED(short, short)
 
 unsigned short owi_unsigned_short(void) {
-
   return magic_size_unsigned(unsigned short);
 }
+OWI_NAMED(unsigned short, unsigned_short)
 
 int owi_int(void) { return magic_size_signed(int); }
+OWI_NAMED(int, int)
 
 unsigned int owi_unsigned_int(void) {
   return magic_size_unsigned(unsigned int);
 }
+OWI_NAMED(unsigned int, unsigned_int)
 
 long owi_long(void) { return magic_size_signed(long); }
+OWI_NAMED(long, long)
 
 unsigned long owi_unsigned_long(void) {
   return magic_size_unsigned(unsigned long);
 }
+OWI_NAMED(unsigned long, unsigned_long)
 
 long long owi_long_long(void) { return magic_size_signed(long long); }
+OWI_NAMED(long long, long_long)
 
 unsigned long long owi_unsigned_long_long(void) {
   return magic_size_unsigned(unsigned long long);
 }
+OWI_NAMED(unsigned long long, unsigned_long_long)
 
 __int128 owi_int128(void) {
   int64_t high64 = owi_int64();
@@ -78,6 +102,7 @@ __int128 owi_int128(void) {
   high128 = high128 << 64;
   return high128 | low128;
 }
+OWI_NAMED(__int128, int128)
 
 unsigned __int128 owi_uint128(void) {
   int64_t high64 = owi_uint64();
@@ -89,3 +114,4 @@ unsigned __int128 owi_uint128(void) {
   high128 = high128 << 64;
   return high128 | low128;
 }
+OWI_NAMED(unsigned __int128, uint128)