Repositories / ecl.git / commitdiff
? search:
summary | shortlog | log | commit | commitdiff | tree
raw | patch | inline | side by side (parent: 3378192)
Reduce the size of the core using GCC's __attribute__((noreturn))
authorJuan Jose Garcia Ripoll <jjgarcia@jjgr-2.local>
Thu, 4 Feb 2010 20:18:24 +0000 (21:18 +0100)
committerJuan Jose Garcia Ripoll <jjgarcia@jjgr-2.local>
Thu, 4 Feb 2010 20:18:24 +0000 (21:18 +0100)
src/c/interpreter.d patch | blob | blame | history
src/h/config.h.in patch | blob | blame | history
src/h/external.h patch | blob | blame | history

diff --git a/src/c/interpreter.d b/src/c/interpreter.d
index ae2c363..a17df78 100644 (file)
--- a/src/c/interpreter.d
+++ b/src/c/interpreter.d
@@ -34,7 +34,7 @@ ecl_stack_set_size(cl_env_ptr env, cl_index tentative_new_size)
         /* Round to page size */
         new_size = (new_size + (LISP_PAGESIZE-1))/LISP_PAGESIZE * new_size;
 
-       if (top > new_size) {
+       if (ecl_unlikely(top > new_size)) {
                FEerror("Internal error: cannot shrink stack below stack top.",0);
         }
 
@@ -93,7 +93,7 @@ ecl_stack_push_values(cl_env_ptr env) {
 void
 ecl_stack_pop_values(cl_env_ptr env, cl_index n) {
         cl_object *p = env->stack_top - n;
-        if (p < env->stack)
+        if (ecl_unlikely(p < env->stack))
                 FEstack_underflow();
         env->nvalues = n;
         env->stack_top = p;
@@ -233,20 +233,6 @@ close_around(cl_object fun, cl_object lex) {
         reg0 = ecl_apply_from_stack_frame((cl_object)&frame, fun);      \
         the_env->stack_top -= __n; }
 
-static void
-undefined_function(cl_object fname)
-{
-       cl_error(3, @'undefined-function', @':name', fname);
-}
-
-static void
-invalid_function(cl_object obj)
-{
-       FEwrong_type_argument(@'function', obj);
-}
-
-
-
 /* -------------------- THE INTERPRETER -------------------- */
 
 cl_object
@@ -303,7 +289,7 @@ ecl_interpret(cl_object frame, cl_object env, cl_object bytecodes)
                cl_object var_name;
                GET_DATA(var_name, vector, data);
                reg0 = ECL_SYM_VAL(the_env, var_name);
-               if (reg0 == OBJNULL)
+               if (ecl_unlikely(reg0 == OBJNULL))
                        FEunbound_variable(var_name);
                THREAD_NEXT;
        }
@@ -319,13 +305,13 @@ ecl_interpret(cl_object frame, cl_object env, cl_object bytecodes)
        }
 
        CASE(OP_CAR); {
-               if (!LISTP(reg0)) FEtype_error_cons(reg0);
+               if (ecl_unlikely(!LISTP(reg0))) FEtype_error_cons(reg0);
                reg0 = CAR(reg0);
                THREAD_NEXT;
        }
 
        CASE(OP_CDR); {
-               if (!LISTP(reg0)) FEtype_error_cons(reg0);
+               if (ecl_unlikely(!LISTP(reg0))) FEtype_error_cons(reg0);
                reg0 = CDR(reg0);
                THREAD_NEXT;
        }
@@ -381,7 +367,8 @@ ecl_interpret(cl_object frame, cl_object env, cl_object bytecodes)
                cl_object var_name, value;
                GET_DATA(var_name, vector, data);
                value = ECL_SYM_VAL(the_env, var_name);
-               if (value == OBJNULL) FEunbound_variable(var_name);
+               if (ecl_unlikely(value == OBJNULL))
+                        FEunbound_variable(var_name);
                ECL_STACK_PUSH(the_env, value);
                THREAD_NEXT;
        }
@@ -465,12 +452,11 @@ ecl_interpret(cl_object frame, cl_object env, cl_object bytecodes)
                frame_aux.base = the_env->stack_top - narg;
                SETUP_ENV(the_env);
        AGAIN:
-               if (reg0 == OBJNULL || reg0 == Cnil) {
-                       undefined_function(x);
-               }
+               if (ecl_unlikely(reg0 == OBJNULL || reg0 == Cnil))
+                       FEundefined_function(x);
                switch (type_of(reg0)) {
                case t_cfunfixed:
-                       if (narg != (cl_index)reg0->cfunfixed.narg)
+                       if (ecl_unlikely(narg != (cl_index)reg0->cfunfixed.narg))
                                FEwrong_num_arguments(reg0);
                        reg0 = APPLY_fixed(narg, reg0->cfunfixed.entry_fixed,
                                            frame_aux.base);
@@ -492,13 +478,13 @@ ecl_interpret(cl_object frame, cl_object env, cl_object bytecodes)
                                reg0 = reg0->instance.slots[reg0->instance.length - 1];
                                goto AGAIN;
                        default:
-                               invalid_function(reg0);
+                               FEinvalid_function(reg0);
                        }
                        break;
 #endif
                case t_symbol:
-                       if (reg0->symbol.stype & stp_macro)
-                               undefined_function(x);
+                       if (ecl_unlikely(reg0->symbol.stype & stp_macro))
+                               FEundefined_function(x);
                        reg0 = SYM_FUN(reg0);
                        goto AGAIN;
                case t_bytecodes:
@@ -508,7 +494,7 @@ ecl_interpret(cl_object frame, cl_object env, cl_object bytecodes)
                        reg0 = ecl_interpret(frame, reg0->bclosure.lex, reg0->bclosure.code);
                        break;
                default:
-                       invalid_function(reg0);
+                       FEinvalid_function(reg0);
                }
                ECL_STACK_POP_N_UNSAFE(the_env, narg);
                THREAD_NEXT;
@@ -533,7 +519,7 @@ ecl_interpret(cl_object frame, cl_object env, cl_object bytecodes)
                 REG0 = T and the value is on the stack, otherwise REG0 = NIL.
        */
        CASE(OP_POPREQ); {
-               if (frame_index >= frame->frame.size) {
+               if (ecl_unlikely(frame_index >= frame->frame.size)) {
                         FEwrong_num_arguments(bytecodes->bytecodes.name);
                 }
                 reg0 = frame->frame.base[frame_index++];
@@ -556,7 +542,7 @@ ecl_interpret(cl_object frame, cl_object env, cl_object bytecodes)
                No more arguments.
         */
         CASE(OP_NOMORE); {
-                if (frame_index < frame->frame.size)
+                if (ecl_unlikely(frame_index < frame->frame.size))
                         FEprogram_error("Too many arguments passed to "
                                         "function ~A~&Argument list: ~S",
                                         2, bytecodes, cl_apply(2, @'list', frame));
@@ -583,7 +569,7 @@ ecl_interpret(cl_object frame, cl_object env, cl_object bytecodes)
                 first = frame->frame.base + frame_index;
                 count = frame->frame.size - frame_index;
                 last = first + count;
-                if (count & 1) {
+                if (ecl_unlikely(count & 1)) {
                         FEprogram_error("Function ~A called with odd number "
                                         "of keyword arguments.",
                                         1, bytecodes);
@@ -617,7 +603,7 @@ ecl_interpret(cl_object frame, cl_object env, cl_object bytecodes)
                                                 count -= 2;
                                         }
                                 }
-                                if (count && (aok & 1) == 0) {
+                                if (ecl_unlikely(count && (aok & 1) == 0)) {
                                         FEprogram_error("Unknown keyword argument "
                                                         "passed to function ~S.~&"
                                                         "Argument list: ~S",
@@ -807,8 +793,8 @@ ecl_interpret(cl_object frame, cl_object env, cl_object bytecodes)
        }
 
        CASE(OP_ENDP);
-               if (!LISTP(reg0)) FEtype_error_list(reg0);
-
+               if (ecl_unlikely(!LISTP(reg0)))
+                        FEtype_error_list(reg0);
        CASE(OP_NOT); {
                reg0 = (reg0 == Cnil)? Ct : Cnil;
                THREAD_NEXT;
@@ -907,7 +893,7 @@ ecl_interpret(cl_object frame, cl_object env, cl_object bytecodes)
                cl_object var;
                GET_DATA(var, vector, data);
                /* INV: Not NIL, and of type t_symbol */
-               if (var->symbol.stype & stp_constant)
+               if (ecl_unlikely(var->symbol.stype & stp_constant))
                        FEassignment_to_constant(var);
                ECL_SETQ(the_env, var, reg0);
                THREAD_NEXT;
@@ -915,7 +901,8 @@ ecl_interpret(cl_object frame, cl_object env, cl_object bytecodes)
        CASE(OP_PSETQ); {
                int lex_env_index;
                GET_OPARG(lex_env_index, vector);
-               ecl_lex_env_set_var(lex_env, lex_env_index, ECL_STACK_POP_UNSAFE(the_env));
+               ecl_lex_env_set_var(lex_env, lex_env_index,
+                                    ECL_STACK_POP_UNSAFE(the_env));
                THREAD_NEXT;
        }
        CASE(OP_PSETQS); {
@@ -1103,7 +1090,7 @@ ecl_interpret(cl_object frame, cl_object env, cl_object bytecodes)
        */
        CASE(OP_NTHVAL); {
                cl_fixnum n = fix(ECL_STACK_POP_UNSAFE(the_env));
-               if (n < 0) {
+               if (ecl_unlikely(n < 0)) {
                        FEerror("Wrong index passed to NTH-VAL", 1, MAKE_FIXNUM(n));
                } else if ((cl_index)n >= the_env->nvalues) {
                        reg0 = Cnil;
diff --git a/src/h/config.h.in b/src/h/config.h.in
index 8463c98..ab5a1e2 100644 (file)
--- a/src/h/config.h.in
+++ b/src/h/config.h.in
@@ -224,6 +224,36 @@ typedef unsigned @CL_FIXNUM_TYPE@ cl_hashkey;
 /* We can use small, two-words conses, without type information                */
 #undef ECL_SMALL_CONS
 
+/*
+ * C macros for inlining, denoting probable code paths and other stuff
+ * that makes better code. Most of it is GCC specific.
+ */
+#if defined(__cplusplus) || (defined(__GNUC__) && !defined(__STRICT_ANSI__))
+#define ECL_INLINE inline
+#else
+#define ECL_INLINE
+#endif
+
+#if !defined(__GNUC__)
+# define ecl_likely(form) (form)
+# define ecl_unlikely(form) (form)
+# define ecl_attr_noreturn
+#else
+# if (__GNUC__ < 3)
+#  define ecl_likely(form) (form)
+#  define ecl_unlikely(form) (form)
+# else
+#  define ecl_likely(form) __builtin_expect(form,1)
+#  define ecl_unlikely(form) __builtin_expect(form,0)
+# endif
+# if (__GNUC__ < 4)
+#  define ecl_attr_noreturn
+# else
+#  define ecl_attr_noreturn __attribute__((noreturn))
+# endif
+#endif
+
+
 /* -CUT-: Everything below this mark will not be installed             */
 /* -------------------------------------------------------------------- *
  *     BUILD OPTIONS WHICH NEED NOT BE EXPORTED                        *
diff --git a/src/h/external.h b/src/h/external.h
index c8923ce..7dabd32 100755 (executable)
--- a/src/h/external.h
+++ b/src/h/external.h
@@ -5,24 +5,6 @@ extern "C" {
 
 #define _ARGS(x) x
 
-#if defined(__cplusplus) || (defined(__GNUC__) && !defined(__STRICT_ANSI__))
-#define ECL_INLINE inline
-#else
-#define ECL_INLINE
-#endif
-#if !defined(__GNUC__)
-# define ecl_likely(form) (form)
-# define ecl_unlikely(form) (form)
-#else
-# if (__GNUC__ < 3)
-#  define ecl_likely(form) (form)
-#  define ecl_unlikely(form) (form)
-# else
-#  define ecl_likely(form) __builtin_expect(form,1)
-#  define ecl_unlikely(form) __builtin_expect(form,0)
-# endif
-#endif
-
 /*
  * Per-thread data.
  */
@@ -358,8 +340,8 @@ extern ECL_API cl_object si_aset _ARGS((cl_narg narg, cl_object v, cl_object x,
 extern ECL_API cl_object si_make_pure_array(cl_object etype, cl_object dims, cl_object adj, cl_object fillp, cl_object displ, cl_object disploff);
 extern ECL_API cl_object si_fill_array_with_elt(cl_object array, cl_object elt, cl_object start, cl_object end);
 
-extern ECL_API void FEwrong_dimensions(cl_object a, cl_index rank);
-extern ECL_API void FEwrong_index(cl_object a, cl_index ndx, cl_index upper);
+extern ECL_API void FEwrong_dimensions(cl_object a, cl_index rank) ecl_attr_noreturn;
+extern ECL_API void FEwrong_index(cl_object a, cl_index ndx, cl_index upper) ecl_attr_noreturn;
 extern ECL_API cl_index ecl_to_index(cl_object n);
 extern ECL_API cl_index ecl_array_dimension(cl_object x, cl_index n);
 extern ECL_API cl_object ecl_aref_unsafe(cl_object x, cl_index index);
@@ -508,9 +490,9 @@ extern ECL_API float ecl_to_float(cl_object x);
 extern ECL_API double ecl_to_double(cl_object x);
 extern ECL_API int ecl_aref_bv(cl_object x, cl_index index);
 extern ECL_API int ecl_aset_bv(cl_object x, cl_index index, int value);
-extern ECL_API void cl_throw(cl_object tag) /*__attribute__((noreturn))*/;
-extern ECL_API void cl_return_from(cl_object block_id, cl_object block_name) /*__attribute__((noreturn))*/;
-extern ECL_API void cl_go(cl_object tag_id, cl_object label) /*__attribute__((noreturn))*/;
+extern ECL_API void cl_throw(cl_object tag) /*ecl_attr_noreturn*/;
+extern ECL_API void cl_return_from(cl_object block_id, cl_object block_name) /*ecl_attr_noreturn*/;
+extern ECL_API void cl_go(cl_object tag_id, cl_object label) /*ecl_attr_noreturn*/;
 extern ECL_API void cl_parse_key(cl_va_list args, int nkey, cl_object *keys, cl_object *vars, cl_object *rest, bool allow_other_keys);
 extern ECL_API cl_object cl_grab_rest_args(cl_va_list args);
 
@@ -536,8 +518,8 @@ extern ECL_API cl_object ecl_stack_frame_pop_values(cl_object f);
 extern ECL_API void ecl_stack_frame_close(cl_object f);
 #define si_apply_from_stack_frame ecl_apply_from_stack_frame
 
-extern ECL_API void FEstack_underflow(void);
-extern ECL_API void FEstack_advance(void);
+extern ECL_API void FEstack_underflow(void) ecl_attr_noreturn;
+extern ECL_API void FEstack_advance(void) ecl_attr_noreturn;
 extern ECL_API cl_object *ecl_stack_grow(cl_env_ptr env);
 extern ECL_API cl_object *ecl_stack_set_size(cl_env_ptr env, cl_index new_size);
 extern ECL_API cl_index ecl_stack_push_values(cl_env_ptr env);
@@ -553,36 +535,36 @@ extern ECL_API cl_object si_bc_split(cl_object v);
 
 /* error.c */
 
-extern ECL_API cl_object cl_error _ARGS((cl_narg narg, cl_object eformat, ...)) /*__attribute__((noreturn))*/;
+extern ECL_API cl_object cl_error _ARGS((cl_narg narg, cl_object eformat, ...)) ecl_attr_noreturn;
 extern ECL_API cl_object cl_cerror _ARGS((cl_narg narg, cl_object cformat, cl_object eformat, ...));
 
-extern ECL_API void ecl_internal_error(const char *s) /*__attribute__((noreturn))*/;
-extern ECL_API void ecl_cs_overflow(void) /*__attribute__((noreturn))*/;
-extern ECL_API void FEprogram_error(const char *s, int narg, ...) /*__attribute__((noreturn))*/;
-extern ECL_API void FEprogram_error_noreturn(const char *s, int narg, ...) __attribute__((noreturn));
-extern ECL_API void FEcontrol_error(const char *s, int narg, ...) /*__attribute__((noreturn))*/;
-extern ECL_API void FEreader_error(const char *s, cl_object stream, int narg, ...) /*__attribute__((noreturn))*/;
+extern ECL_API void ecl_internal_error(const char *s) /*ecl_attr_noreturn*/;
+extern ECL_API void ecl_cs_overflow(void) /*ecl_attr_noreturn*/;
+extern ECL_API void FEprogram_error(const char *s, int narg, ...) ecl_attr_noreturn;
+extern ECL_API void FEprogram_error_noreturn(const char *s, int narg, ...) ecl_attr_noreturn;
+extern ECL_API void FEcontrol_error(const char *s, int narg, ...) ecl_attr_noreturn;
+extern ECL_API void FEreader_error(const char *s, cl_object stream, int narg, ...) ecl_attr_noreturn;
 #define FEparse_error FEreader_error
-extern ECL_API void FEerror(const char *s, int narg, ...) /*__attribute__((noreturn))*/;
-extern ECL_API void FEcannot_open(cl_object fn) /*__attribute__((noreturn))*/;
-extern ECL_API void FEend_of_file(cl_object strm) /*__attribute__((noreturn))*/;
-extern ECL_API void FEclosed_stream(cl_object strm) /*__attribute__ ((noreturn))*/;
-extern ECL_API void FEwrong_type_argument(cl_object type, cl_object value) /*__attribute__((noreturn))*/;
-extern ECL_API void FEwrong_num_arguments(cl_object fun) __attribute__((noreturn));
-extern ECL_API void FEwrong_num_arguments_anonym(void) __attribute__((noreturn));
-extern ECL_API void FEunbound_variable(cl_object sym) /*__attribute__((noreturn))*/;
-extern ECL_API void FEinvalid_macro_call(cl_object obj) /*__attribute__((noreturn))*/;
-extern ECL_API void FEinvalid_variable(const char *s, cl_object obj) /*__attribute__((noreturn))*/;
-extern ECL_API void FEassignment_to_constant(cl_object v) /*__attribute__((noreturn))*/;
-extern ECL_API void FEundefined_function(cl_object fname) __attribute__((noreturn));
-extern ECL_API void FEinvalid_function(cl_object obj) __attribute__((noreturn));
-extern ECL_API void FEinvalid_function_name(cl_object obj) /*__attribute__((noreturn))*/;
+extern ECL_API void FEerror(const char *s, int narg, ...) ecl_attr_noreturn;
+extern ECL_API void FEcannot_open(cl_object fn) ecl_attr_noreturn;
+extern ECL_API void FEend_of_file(cl_object strm) ecl_attr_noreturn;
+extern ECL_API void FEclosed_stream(cl_object strm) ecl_attr_noreturn;
+extern ECL_API void FEwrong_type_argument(cl_object type, cl_object value) ecl_attr_noreturn;
+extern ECL_API void FEwrong_num_arguments(cl_object fun) ecl_attr_noreturn;
+extern ECL_API void FEwrong_num_arguments_anonym(void) ecl_attr_noreturn;
+extern ECL_API void FEunbound_variable(cl_object sym) ecl_attr_noreturn;
+extern ECL_API void FEinvalid_macro_call(cl_object obj) ecl_attr_noreturn;
+extern ECL_API void FEinvalid_variable(const char *s, cl_object obj) ecl_attr_noreturn;
+extern ECL_API void FEassignment_to_constant(cl_object v) ecl_attr_noreturn;
+extern ECL_API void FEundefined_function(cl_object fname) ecl_attr_noreturn;
+extern ECL_API void FEinvalid_function(cl_object obj) ecl_attr_noreturn;
+extern ECL_API void FEinvalid_function_name(cl_object obj) ecl_attr_noreturn;
 extern ECL_API cl_object CEerror(cl_object c, const char *err_str, int narg, ...);
-extern ECL_API void FEillegal_index(cl_object x, cl_object i);
-extern ECL_API void FEtype_error_symbol(cl_object obj) /*__attribute__((noreturn))*/;
-extern ECL_API void FElibc_error(const char *msg, int narg, ...) /*__attribute__((noreturn))*/;
+extern ECL_API void FEillegal_index(cl_object x, cl_object i) ecl_attr_noreturn;
+extern ECL_API void FEtype_error_symbol(cl_object obj) ecl_attr_noreturn;
+extern ECL_API void FElibc_error(const char *msg, int narg, ...) ecl_attr_noreturn;
 #if defined(mingw32) || defined(_MSC_VER) || defined(cygwin)
-extern ECL_API void FEwin32_error(const char *msg, int narg, ...) /*__attribute__((noreturn))*/;
+extern ECL_API void FEwin32_error(const char *msg, int narg, ...) ecl_attr_noreturn;
 #endif
 
 /* eval.c */
@@ -932,8 +914,8 @@ extern ECL_API cl_object si_getenv(cl_object var);
 extern ECL_API cl_object si_setenv(cl_object var, cl_object value);
 extern ECL_API cl_object si_environ(void);
 extern ECL_API cl_object si_pointer(cl_object x);
-extern ECL_API cl_object si_quit _ARGS((cl_narg narg, ...)) /*__attribute__((noreturn))*/;
-extern ECL_API cl_object si_exit _ARGS((cl_narg narg, ...)) /*__attribute__((noreturn))*/;
+extern ECL_API cl_object si_quit _ARGS((cl_narg narg, ...)) /*ecl_attr_noreturn*/;
+extern ECL_API cl_object si_exit _ARGS((cl_narg narg, ...)) /*ecl_attr_noreturn*/;
 
 typedef enum {
        ECL_OPT_INCREMENTAL_GC = 0,
@@ -1520,7 +1502,7 @@ extern ECL_API cl_object si_get_limit(cl_object type);
 
 extern ECL_API cl_index ecl_progv(cl_env_ptr env, cl_object vars, cl_object values);
 extern ECL_API void ecl_bds_unwind(cl_env_ptr env, cl_index new_bds_top_index);
-extern ECL_API void ecl_unwind(cl_env_ptr env, struct ecl_frame *fr) /*__attribute__((noreturn))*/;
+extern ECL_API void ecl_unwind(cl_env_ptr env, struct ecl_frame *fr) /*ecl_attr_noreturn*/;
 extern ECL_API struct ecl_frame *frs_sch(cl_object frame_id);
 
 /* string.c */
@@ -1636,7 +1618,7 @@ extern ECL_API void ecl_tcp_close_all(void);
 #ifdef ECL_THREADS
 extern ECL_API cl_object mp_own_process(void) __attribute__((const));
 extern ECL_API cl_object mp_all_processes(void);
-extern ECL_API cl_object mp_exit_process(void) /*__attribute__((noreturn))*/;
+extern ECL_API cl_object mp_exit_process(void) /*ecl_attr_noreturn*/;
 extern ECL_API cl_object mp_interrupt_process(cl_object process, cl_object function);
 extern ECL_API cl_object mp_make_process _ARGS((cl_narg narg, ...));
 extern ECL_API cl_object mp_process_active_p(cl_object process);
@@ -1710,24 +1692,24 @@ extern ECL_API void assert_type_list(cl_object p);
 extern ECL_API void assert_type_proper_list(cl_object p);
 extern ECL_API cl_object cl_type_of(cl_object x);
 
-extern ECL_API void FEtype_error_character(cl_object x) /*__attribute__((noreturn))*/;
-extern ECL_API void FEtype_error_cons(cl_object x) /*__attribute__((noreturn))*/;
-extern ECL_API void FEtype_error_number(cl_object x) /*__attribute__((noreturn))*/;
-extern ECL_API void FEtype_error_real(cl_object x) /*__attribute__((noreturn))*/;
-extern ECL_API void FEtype_error_float(cl_object x) /*__attribute__((noreturn))*/;
-extern ECL_API void FEtype_error_integer(cl_object x) /*__attribute__((noreturn))*/;
-extern ECL_API void FEtype_error_list(cl_object x) /*__attribute__((noreturn))*/;
-extern ECL_API void FEtype_error_proper_list(cl_object x) /*__attribute__((noreturn))*/;
-extern ECL_API void FEtype_error_alist(cl_object x) /*__attribute__((noreturn))*/;
-extern ECL_API void FEtype_error_stream(cl_object x) /*__attribute__((noreturn))*/;
-extern ECL_API void FEtype_error_sequence(cl_object x) /*__attribute__((noreturn))*/;
-extern ECL_API void FEtype_error_instance(cl_object x) /*__attribute__((noreturn))*/;
-extern ECL_API void FEcircular_list(cl_object x) /*__attribute__((noreturn))*/;
-extern ECL_API void FEtype_error_index(cl_object seq, cl_object ndx) /*__attribute__((noreturn))*/;
-extern ECL_API void FEtype_error_array(cl_object x) /*__attribute__((noreturn))*/;
-extern ECL_API void FEtype_error_vector(cl_object x) /*__attribute__((noreturn))*/;
-extern ECL_API void FEtype_error_string(cl_object x) /*__attribute__((noreturn))*/;
-extern ECL_API void FEdivision_by_zero(cl_object x, cl_object y) /*__attribute__((noreturn))*/;
+extern ECL_API void FEtype_error_character(cl_object x) ecl_attr_noreturn;
+extern ECL_API void FEtype_error_cons(cl_object x) ecl_attr_noreturn;
+extern ECL_API void FEtype_error_number(cl_object x) ecl_attr_noreturn;
+extern ECL_API void FEtype_error_real(cl_object x) ecl_attr_noreturn;
+extern ECL_API void FEtype_error_float(cl_object x) ecl_attr_noreturn;
+extern ECL_API void FEtype_error_integer(cl_object x) ecl_attr_noreturn;
+extern ECL_API void FEtype_error_list(cl_object x) ecl_attr_noreturn;
+extern ECL_API void FEtype_error_proper_list(cl_object x) ecl_attr_noreturn;
+extern ECL_API void FEtype_error_alist(cl_object x) ecl_attr_noreturn;
+extern ECL_API void FEtype_error_stream(cl_object x) ecl_attr_noreturn;
+extern ECL_API void FEtype_error_sequence(cl_object x) ecl_attr_noreturn;
+extern ECL_API void FEtype_error_instance(cl_object x) ecl_attr_noreturn;
+extern ECL_API void FEcircular_list(cl_object x) ecl_attr_noreturn;
+extern ECL_API void FEtype_error_index(cl_object seq, cl_object ndx) ecl_attr_noreturn;
+extern ECL_API void FEtype_error_array(cl_object x) ecl_attr_noreturn;
+extern ECL_API void FEtype_error_vector(cl_object x) ecl_attr_noreturn;
+extern ECL_API void FEtype_error_string(cl_object x) ecl_attr_noreturn;
+extern ECL_API void FEdivision_by_zero(cl_object x, cl_object y) ecl_attr_noreturn;
 extern ECL_API cl_object ecl_type_error(cl_object function, const char *place, cl_object o, cl_object type);
 extern ECL_API cl_object ecl_check_cl_type(cl_object fun, cl_object p, cl_type t);
 extern ECL_API cl_object ecl_check_type_string(cl_object fun, cl_object p);
@@ -1880,8 +1862,8 @@ extern ECL_API cl_object cl_decode_universal_time _ARGS((cl_narg narg, cl_object
 extern ECL_API cl_object cl_encode_universal_time _ARGS((cl_narg narg, cl_object V1, cl_object V2, cl_object V3, cl_object V4, cl_object V5, cl_object V6, ...));
 extern ECL_API cl_object cl_get_decoded_time();
 extern ECL_API cl_object cl_ensure_directories_exist _ARGS((cl_narg narg, cl_object V1, ...));
-extern ECL_API cl_object si_simple_program_error _ARGS((cl_narg narg, cl_object format, ...)) /*__attribute__((noreturn))*/;
-extern ECL_API cl_object si_signal_simple_error _ARGS((cl_narg narg, cl_object condition, cl_object continuable, cl_object format, cl_object args, ...)) /*__attribute__((noreturn))*/;
+extern ECL_API cl_object si_simple_program_error _ARGS((cl_narg narg, cl_object format, ...)) ecl_attr_noreturn;
+extern ECL_API cl_object si_signal_simple_error _ARGS((cl_narg narg, cl_object condition, cl_object continuable, cl_object format, cl_object args, ...)) ecl_attr_noreturn;
 
 /* module.lsp */
 
Embeddable Common Lisp (Official: https://gitlab.com/embeddable-common-lisp/ecl)