Ticket #105: diff.trunk.assert_args.txt

File diff.trunk.assert_args.txt, 19.0 KB (added by jkeenan, 5 years ago)

Work done so far in the 'assert_args' branch.

Line 
1Index: src/embed.c
2===================================================================
3--- src/embed.c (.../trunk)     (revision 34776)
4+++ src/embed.c (.../branches/assert_args)      (revision 34785)
5@@ -836,6 +836,7 @@
6 {
7     opcode_t i;
8     PMC *sub_pmc;
9+    ASSERT_ARGS(set_current_sub);
10 
11     PackFile_ByteCode   * const cur_cs = interp->code;
12     PackFile_FixupTable * const ft     = cur_cs->fixups;
13Index: src/pbc_merge.c
14===================================================================
15--- src/pbc_merge.c     (.../trunk)     (revision 34776)
16+++ src/pbc_merge.c     (.../branches/assert_args)      (revision 34785)
17@@ -233,6 +233,7 @@
18     INTVAL program_size, wanted;
19     char *program_code;
20     PackFile *pf;
21+    ASSERT_ARGS(pbc_merge_loadpbc);
22     FILE * io = NULL;
23     INTVAL is_mapped = 0;
24     size_t chunk_size;
25@@ -321,9 +322,10 @@
26 pbc_merge_bytecode(PARROT_INTERP, ARGMOD(pbc_merge_input **inputs),
27                    int num_inputs, ARGMOD(PackFile *pf))
28 {
29+    int i;
30+    ASSERT_ARGS(pbc_merge_bytecode);
31     opcode_t *bc = mem_allocate_typed(opcode_t);
32     opcode_t cursor = 0;
33-    int i;
34 
35     /* Add a bytecode segment. */
36     PackFile_ByteCode * const bc_seg =
37@@ -385,9 +387,10 @@
38 pbc_merge_constants(PARROT_INTERP, ARGMOD(pbc_merge_input **inputs),
39                     int num_inputs, ARGMOD(PackFile *pf), ARGMOD(PackFile_ByteCode *bc))
40 {
41+    int i, j;
42+    ASSERT_ARGS(pbc_merge_constants);
43     PackFile_Constant   **constants = mem_allocate_typed(PackFile_Constant *);
44     opcode_t cursor = 0;
45-    int i, j;
46 
47     /* Add a constant table segment. */
48     PackFile_ConstTable * const const_seg = (PackFile_ConstTable*)PackFile_Segment_new_seg(
49@@ -480,10 +483,11 @@
50 pbc_merge_fixups(PARROT_INTERP, ARGIN(pbc_merge_input **inputs),
51                  int num_inputs, ARGMOD(PackFile *pf), ARGMOD(PackFile_ByteCode *bc))
52 {
53+    int i, j;
54+    ASSERT_ARGS(pbc_merge_fixups);
55     PackFile_FixupTable *fixup_seg;
56     PackFile_FixupEntry **fixups = mem_allocate_typed(PackFile_FixupEntry *);
57     opcode_t cursor = 0;
58-    int i, j;
59 
60     /* Add a fixup table segment. */
61     fixup_seg = (PackFile_FixupTable*)PackFile_Segment_new_seg(
62@@ -575,13 +579,14 @@
63 pbc_merge_debugs(PARROT_INTERP, ARGMOD(pbc_merge_input **inputs),
64                  int num_inputs, ARGMOD(PackFile *pf), ARGMOD(PackFile_ByteCode *bc))
65 {
66+    int i, j;
67+    ASSERT_ARGS(pbc_merge_debugs);
68     PackFile_Debug *debug_seg;
69     opcode_t *lines                  = mem_allocate_typed(opcode_t);
70     PackFile_DebugMapping **mappings =
71         mem_allocate_typed(PackFile_DebugMapping *);
72     opcode_t num_mappings = 0;
73     opcode_t num_lines    = 0;
74-    int i, j;
75 
76     /* We need to merge both the mappings and the list of line numbers.
77        The line numbers can just be concatenated. The mappings must have
78@@ -648,6 +653,7 @@
79     int i;
80     PackFile_Segment *pic_index;
81     size_t size;
82+    ASSERT_ARGS(pbc_merge_pic_index);
83     opcode_t cursor = 0;
84     opcode_t start = 0;
85     opcode_t last = 0;
86@@ -697,11 +703,12 @@
87 pbc_merge_ctpointers(PARROT_INTERP, ARGMOD(pbc_merge_input **inputs),
88                      int num_inputs, ARGMOD(PackFile_ByteCode *bc))
89 {
90+    int        cur_arg;
91     opcode_t  *op_ptr;
92+    ASSERT_ARGS(pbc_merge_ctpointers);
93     opcode_t  *ops       = bc->base.data;
94     opcode_t   cur_op    = 0;
95     int        cur_input = 0;
96-    int        cur_arg;
97 
98     /* Loop over the ops in the merged bytecode. */
99     while (cur_op < (opcode_t)bc->base.size) {
100@@ -781,6 +788,7 @@
101 {
102     PackFile_ByteCode   *bc;
103     PackFile_ConstTable *ct;
104+    ASSERT_ARGS(pbc_merge_begin);
105 
106     /* Create a new empty packfile. */
107     PackFile * const merged = PackFile_new(interp, 0);
108@@ -819,6 +827,7 @@
109 static void
110 pbc_merge_write(PARROT_INTERP, ARGMOD(PackFile *pf), ARGIN(const char *filename))
111 {
112+    ASSERT_ARGS(pbc_merge_write);
113     FILE     *fp;
114 
115     /* Get size of packfile we'll write. */
116Index: src/charset.c
117===================================================================
118--- src/charset.c       (.../trunk)     (revision 34776)
119+++ src/charset.c       (.../branches/assert_args)      (revision 34785)
120@@ -96,6 +96,7 @@
121 CHARSET *
122 Parrot_new_charset(SHIM_INTERP)
123 {
124+    ASSERT_ARGS(Parrot_new_charset);
125     return mem_allocate_typed(CHARSET);
126 }
127 
128@@ -114,8 +115,9 @@
129 void
130 Parrot_charsets_encodings_deinit(SHIM_INTERP)
131 {
132+    int i;
133+    ASSERT_ARGS(Parrot_charsets_encodings_deinit);
134     const int n = all_charsets->n_charsets;
135-    int i;
136 
137     for (i = 0; i < n; ++i) {
138         if (all_charsets->set[i].n_converters)
139@@ -146,6 +148,7 @@
140 Parrot_find_charset(SHIM_INTERP, ARGIN(const char *charsetname))
141 {
142     int i;
143+    ASSERT_ARGS(Parrot_find_charset);
144     const int n = all_charsets->n_charsets;
145 
146     for (i = 0; i < n; ++i) {
147@@ -172,6 +175,7 @@
148 CHARSET *
149 Parrot_load_charset(PARROT_INTERP, ARGIN(const char *charsetname))
150 {
151+    ASSERT_ARGS(Parrot_load_charset);
152     UNUSED(charsetname);
153 
154     Parrot_ex_throw_from_c_args(interp, NULL, EXCEPTION_UNIMPLEMENTED,
155@@ -193,8 +197,9 @@
156 INTVAL
157 Parrot_charset_number(PARROT_INTERP, ARGIN(const STRING *charsetname))
158 {
159+    int i;
160+    ASSERT_ARGS(Parrot_charset_number);
161     const int n = all_charsets->n_charsets;
162-    int i;
163 
164     for (i = 0; i < n; ++i) {
165         if (!string_equal(interp, all_charsets->set[i].name, charsetname))
166@@ -219,6 +224,7 @@
167 Parrot_charset_number_of_str(SHIM_INTERP, ARGIN(const STRING *src))
168 {
169     int i;
170+    ASSERT_ARGS(Parrot_charset_number_of_str);
171     const int n = all_charsets->n_charsets;
172 
173     for (i = 0; i < n; ++i) {
174@@ -245,6 +251,7 @@
175 STRING*
176 Parrot_charset_name(SHIM_INTERP, INTVAL number_of_charset)
177 {
178+    ASSERT_ARGS(Parrot_charset_name);
179     if (number_of_charset < 0 || number_of_charset >= all_charsets->n_charsets)
180         return NULL;
181     return all_charsets->set[number_of_charset].name;
182@@ -266,6 +273,7 @@
183 const CHARSET *
184 Parrot_get_charset(SHIM_INTERP, INTVAL number_of_charset)
185 {
186+    ASSERT_ARGS(Parrot_get_charset);
187     if (number_of_charset < 0 || number_of_charset >= all_charsets->n_charsets)
188         return NULL;
189     return all_charsets->set[number_of_charset].charset;
190@@ -288,6 +296,7 @@
191 const char *
192 Parrot_charset_c_name(SHIM_INTERP, INTVAL number_of_charset)
193 {
194+    ASSERT_ARGS(Parrot_charset_c_name);
195     if (number_of_charset < 0 || number_of_charset >= all_charsets->n_charsets)
196         return NULL;
197     return all_charsets->set[number_of_charset].charset->name;
198@@ -309,8 +318,9 @@
199 register_charset(PARROT_INTERP, ARGIN(const char *charsetname),
200         ARGIN(CHARSET *charset))
201 {
202+    int i;
203+    ASSERT_ARGS(register_charset);
204     const int n = all_charsets->n_charsets;
205-    int i;
206 
207     for (i = 0; i < n; ++i) {
208         if (STREQ(all_charsets->set[i].charset->name, charsetname))
209@@ -352,6 +362,7 @@
210 static void
211 register_static_converters(PARROT_INTERP)
212 {
213+    ASSERT_ARGS(register_static_converters);
214     Parrot_register_charset_converter(interp,
215             Parrot_iso_8859_1_charset_ptr, Parrot_ascii_charset_ptr,
216             charset_cvt_iso_8859_1_to_ascii);
217@@ -391,6 +402,7 @@
218 Parrot_register_charset(PARROT_INTERP, ARGIN(const char *charsetname),
219         ARGIN(CHARSET *charset))
220 {
221+    ASSERT_ARGS(Parrot_register_charset);
222     if (!all_charsets) {
223         all_charsets = mem_allocate_typed(All_charsets);
224         all_charsets->n_charsets = 0;
225@@ -433,6 +445,7 @@
226 void
227 Parrot_charsets_encodings_init(PARROT_INTERP)
228 {
229+    ASSERT_ARGS(Parrot_charsets_encodings_init);
230     /* the order is crucial here:
231      * 1) encodings, default = fixed_8
232      * 2) charsets   default = ascii
233@@ -472,6 +485,7 @@
234 Parrot_make_default_charset(SHIM_INTERP, SHIM(const char *charsetname),
235         ARGIN(CHARSET *charset))
236 {
237+    ASSERT_ARGS(Parrot_make_default_charset);
238     Parrot_default_charset_ptr = charset;
239     return 1;
240 }
241@@ -492,6 +506,7 @@
242 const CHARSET *
243 Parrot_default_charset(SHIM_INTERP)
244 {
245+    ASSERT_ARGS(Parrot_default_charset);
246     return Parrot_default_charset_ptr;
247 }
248 
249@@ -513,6 +528,7 @@
250         ARGIN(const CHARSET *lhs), ARGIN(const CHARSET *rhs))
251 {
252     int i;
253+    ASSERT_ARGS(Parrot_find_charset_converter);
254     const int n = all_charsets->n_charsets;
255 
256     for (i = 0; i < n; ++i) {
257@@ -546,8 +562,9 @@
258         ARGIN(const CHARSET *lhs), ARGIN(CHARSET *rhs),
259         ARGIN(charset_converter_t func))
260 {
261+    int i;
262+    ASSERT_ARGS(Parrot_register_charset_converter);
263     const int n = all_charsets->n_charsets;
264-    int i;
265 
266     for (i = 0; i < n; ++i) {
267         if (lhs == all_charsets->set[i].charset) {
268Index: src/exec.c
269===================================================================
270--- src/exec.c  (.../trunk)     (revision 34776)
271+++ src/exec.c  (.../branches/assert_args)      (revision 34785)
272@@ -49,6 +49,10 @@
273         __attribute__nonnull__(1)
274         __attribute__nonnull__(2);
275 
276+#define ASSERT_ARGS_add_data_member assert(obj);
277+#define ASSERT_ARGS_exec_init assert(obj);
278+#define ASSERT_ARGS_symbol_list_find assert(obj); \
279+                                     assert(symbol);
280 /* Don't modify between HEADERIZER BEGIN / HEADERIZER END.  Your changes will be lost. */
281 /* HEADERIZER END: static */
282 
283@@ -362,6 +366,7 @@
284 symbol_list_find(ARGIN(const Parrot_exec_objfile_t *obj), ARGIN(const char *symbol))
285 {
286     int i;
287+    ASSERT_ARGS(symbol_list_find);
288 
289     for (i = 0; i < obj->symbol_count; i++)
290         if (STREQ(symbol, obj->symbol_table[i].symbol))
291Index: src/inter_run.c
292===================================================================
293--- src/inter_run.c     (.../trunk)     (revision 34776)
294+++ src/inter_run.c     (.../branches/assert_args)      (revision 34785)
295@@ -64,6 +64,7 @@
296 void
297 runops(PARROT_INTERP, size_t offs)
298 {
299+    ASSERT_ARGS(runops);
300     volatile size_t offset            = offs;
301     const    int    old_runloop_id    = interp->current_runloop_id;
302     const    int    our_runloop_level = ++interp->current_runloop_level;
303@@ -138,6 +139,7 @@
304 {
305     opcode_t offset, *dest;
306     Parrot_Context *ctx;
307+    ASSERT_ARGS(Parrot_runops_fromc);
308 
309     /* we need one return continuation with a NULL offset */
310     PMC * const ret_c    = new_ret_continuation_pmc(interp, NULL);
311@@ -195,6 +197,7 @@
312 
313     char new_sig[10];
314     const char *sig_p;
315+    ASSERT_ARGS(runops_args);
316     Parrot_Context * const old_ctx = CONTEXT(interp);
317 
318     interp->current_cont  = new_ret_continuation_pmc(interp, NULL);
319@@ -269,6 +272,7 @@
320     Parrot_Context *ctx;
321     opcode_t offset, *dest;
322 
323+    ASSERT_ARGS(Parrot_run_meth_fromc);
324     interp->current_cont   = new_ret_continuation_pmc(interp, NULL);
325     interp->current_object = obj;
326     dest                   = VTABLE_invoke(interp, sub, (void *)1);
327@@ -304,6 +308,7 @@
328     va_list args;
329     Parrot_Context *ctx;
330     PMC *retval;
331+    ASSERT_ARGS(Parrot_runops_fromc_args);
332 
333     va_start(args, sig);
334     ctx = runops_args(interp, sub, PMCNULL, NULL, sig, args);
335@@ -335,6 +340,7 @@
336     va_list args;
337     Parrot_Context *ctx;
338     void *retval;
339+    ASSERT_ARGS(Parrot_runops_fromc_args_event);
340     /*
341      * running code from event handlers isn't fully reentrant due to
342      * these interpreter variables - mainly related to calls
343@@ -379,6 +385,7 @@
344     va_list args;
345     Parrot_Context *ctx;
346     INTVAL retval;
347+    ASSERT_ARGS(Parrot_runops_fromc_args_reti);
348 
349     va_start(args, sig);
350     ctx = runops_args(interp, sub, PMCNULL, NULL, sig, args);
351@@ -409,6 +416,7 @@
352     va_list args;
353     Parrot_Context *ctx;
354     FLOATVAL retval;
355+    ASSERT_ARGS(Parrot_runops_fromc_args_retf);
356 
357     va_start(args, sig);
358     ctx = runops_args(interp, sub, PMCNULL, NULL, sig, args);
359@@ -440,6 +448,7 @@
360     va_list args;
361     Parrot_Context *ctx;
362     void* retval;
363+    ASSERT_ARGS(Parrot_run_meth_fromc_args);
364 
365     va_start(args, sig);
366     ctx = runops_args(interp, sub, obj, meth, sig, args);
367@@ -470,6 +479,7 @@
368     va_list args;
369     Parrot_Context *ctx;
370     INTVAL retval;
371+    ASSERT_ARGS(Parrot_run_meth_fromc_args_reti);
372 
373     va_start(args, sig);
374     ctx = runops_args(interp, sub, obj, meth, sig, args);
375@@ -500,6 +510,7 @@
376     va_list args;
377     Parrot_Context *ctx;
378     FLOATVAL retval;
379+    ASSERT_ARGS(Parrot_run_meth_fromc_args_retf);
380 
381     va_start(args, sig);
382     ctx = runops_args(interp, sub, obj, meth, sig, args);
383@@ -529,6 +540,7 @@
384         ARGIN(const char *sig), va_list args)
385 {
386     void* retval;
387+    ASSERT_ARGS(Parrot_runops_fromc_arglist);
388     Parrot_Context * const ctx = runops_args(interp, sub, PMCNULL, NULL, sig, args);
389 
390     retval = set_retval(interp, *sig, ctx);
391@@ -555,6 +567,7 @@
392         ARGIN(const char *sig), va_list args)
393 {
394     INTVAL retval;
395+    ASSERT_ARGS(Parrot_runops_fromc_arglist_reti);
396     Parrot_Context * const ctx = runops_args(interp, sub, PMCNULL, NULL, sig, args);
397 
398     retval = set_retval_i(interp, *sig, ctx);
399@@ -581,6 +594,7 @@
400         ARGIN(const char *sig), va_list args)
401 {
402     FLOATVAL retval;
403+    ASSERT_ARGS(Parrot_runops_fromc_arglist_retf);
404     Parrot_Context * const ctx = runops_args(interp, sub, PMCNULL, NULL, sig, args);
405 
406     retval = set_retval_f(interp, *sig, ctx);
407@@ -609,6 +623,7 @@
408 {
409     Parrot_Context *ctx;
410     void* retval;
411+    ASSERT_ARGS(Parrot_run_meth_fromc_arglist);
412 
413     ctx = runops_args(interp, sub, obj, meth, sig, args);
414     retval = set_retval(interp, *sig, ctx);
415@@ -637,6 +652,7 @@
416         ARGIN(STRING *meth), ARGIN(const char *sig), va_list args)
417 {
418     INTVAL retval;
419+    ASSERT_ARGS(Parrot_run_meth_fromc_arglist_reti);
420     Parrot_Context * const ctx = runops_args(interp, sub, obj, meth, sig, args);
421 
422     retval = set_retval_i(interp, *sig, ctx);
423@@ -664,6 +680,7 @@
424         ARGIN(STRING *meth), ARGIN(const char *sig), va_list args)
425 {
426     FLOATVAL retval;
427+    ASSERT_ARGS(Parrot_run_meth_fromc_arglist_retf);
428     Parrot_Context * const ctx = runops_args(interp, sub, obj, meth, sig, args);
429 
430     retval = set_retval_f(interp, *sig, ctx);
431@@ -693,6 +710,7 @@
432 new_runloop_jump_point(PARROT_INTERP)
433 {
434     Parrot_runloop *jump_point;
435+    ASSERT_ARGS(new_runloop_jump_point);
436 
437     if (interp->runloop_jmp_free_list) {
438         jump_point                    = interp->runloop_jmp_free_list;
439@@ -719,6 +737,7 @@
440 void
441 free_runloop_jump_point(PARROT_INTERP)
442 {
443+    ASSERT_ARGS(free_runloop_jump_point);
444     Parrot_runloop * const jump_point = interp->current_runloop;
445     interp->current_runloop           = jump_point->prev;
446     jump_point->prev                  = interp->runloop_jmp_free_list;
447@@ -739,6 +758,7 @@
448 void
449 destroy_runloop_jump_points(PARROT_INTERP)
450 {
451+    ASSERT_ARGS(destroy_runloop_jump_points);
452     really_destroy_runloop_jump_points(interp->current_runloop);
453     really_destroy_runloop_jump_points(interp->runloop_jmp_free_list);
454 }
455@@ -758,6 +778,7 @@
456 void
457 really_destroy_runloop_jump_points(ARGIN_NULLOK(Parrot_runloop *jump_point))
458 {
459+    ASSERT_ARGS(really_destroy_runloop_jump_points);
460     while (jump_point) {
461         Parrot_runloop * const prev = jump_point->prev;
462         mem_sys_free(jump_point);
463Index: include/parrot/atomic/gcc_x86.h
464===================================================================
465--- include/parrot/atomic/gcc_x86.h     (.../trunk)     (revision 34776)
466+++ include/parrot/atomic/gcc_x86.h     (.../branches/assert_args)      (revision 34785)
467@@ -33,6 +33,10 @@
468 long parrot_i386_xadd(ARGIN(volatile long *l), long amount)
469         __attribute__nonnull__(1);
470 
471+#define ASSERT_ARGS_parrot_i386_cmpxchg assert(ptr); \
472+                                        assert(expect); \
473+                                        assert(update);
474+#define ASSERT_ARGS_parrot_i386_xadd assert(l);
475 /* Don't modify between HEADERIZER BEGIN / HEADERIZER END.  Your changes will be lost. */
476 /* HEADERIZER END: src/atomic/gcc_x86.c */
477 
478Index: include/parrot/exec.h
479===================================================================
480--- include/parrot/exec.h       (.../trunk)     (revision 34776)
481+++ include/parrot/exec.h       (.../branches/assert_args)      (revision 34785)
482@@ -149,6 +149,21 @@
483         __attribute__nonnull__(2)
484         FUNC_MODIFIES(*obj);
485 
486+#define ASSERT_ARGS_Parrot_exec_add_text_rellocation assert(obj); \
487+                                                     assert(nptr); \
488+                                                     assert(symbol);
489+#define ASSERT_ARGS_Parrot_exec_add_text_rellocation_func assert(obj); \
490+                                                          assert(nptr); \
491+                                                          assert(func_name);
492+#define ASSERT_ARGS_Parrot_exec_add_text_rellocation_reg assert(obj); \
493+                                                         assert(nptr); \
494+                                                         assert(var);
495+#define ASSERT_ARGS_Parrot_exec assert(interp); \
496+                                assert(pc); \
497+                                assert(code_start); \
498+                                assert(code_end);
499+#define ASSERT_ARGS_Parrot_exec_add_symbol assert(obj); \
500+                                           assert(symbol);
501 /* Don't modify between HEADERIZER BEGIN / HEADERIZER END.  Your changes will be lost. */
502 /* HEADERIZER END: src/exec.c */
503 
504Index: compilers/imcc/sets.c
505===================================================================
506--- compilers/imcc/sets.c       (.../trunk)     (revision 34776)
507+++ compilers/imcc/sets.c       (.../branches/assert_args)      (revision 34785)
508@@ -51,6 +51,7 @@
509 Set*
510 set_make(unsigned int length)
511 {
512+    ASSERT_ARGS(set_make);
513     Set * const s = mem_allocate_zeroed_typed(Set);
514     s->length     = length;
515     s->bmp        = mem_allocate_n_zeroed_typed(NUM_BYTES(length),
516@@ -75,6 +76,7 @@
517 Set*
518 set_make_full(unsigned int length)
519 {
520+    ASSERT_ARGS(set_make_full);
521     Set * const s      = set_make(length);
522     const size_t bytes = NUM_BYTES(length);
523 
524@@ -98,6 +100,7 @@
525 void
526 set_free(ARGMOD(Set *s))
527 {
528+    ASSERT_ARGS(set_free);
529     if (s->bmp)
530         mem_sys_free(s->bmp);
531 
532@@ -118,6 +121,7 @@
533 void
534 set_clear(ARGMOD(Set *s))
535 {
536+    ASSERT_ARGS(set_clear);
537     memset(s->bmp, 0, NUM_BYTES(s->length));
538 }
539 
540@@ -137,6 +141,7 @@
541 Set*
542 set_copy(ARGIN(const Set *s))
543 {
544+    ASSERT_ARGS(set_copy);
545     Set * const d = set_make(s->length);
546 
547     memcpy(d->bmp, s->bmp, NUM_BYTES(d->length));
548@@ -161,6 +166,7 @@
549 set_equal(ARGIN(const Set *s1), ARGIN(const Set *s2))
550 {
551     int          mask;
552+    ASSERT_ARGS(set_equal);
553     const size_t bytes = s1->length / 8;
554 
555     if (s1->length != s2->length)
556@@ -195,6 +201,7 @@
557 void
558 set_add(ARGMOD(Set *s), unsigned int element)
559 {
560+    ASSERT_ARGS(set_add);
561     const int elem_byte_in_set = BYTE_IN_SET(element);
562     const int bytes_in_set     = BYTE_IN_SET(s->length);
563 
564@@ -295,6 +302,7 @@
565 set_union(ARGIN(const Set *s1), ARGIN(const Set *s2))
566 {
567     unsigned int i;
568+    ASSERT_ARGS(set_union);
569     Set * const s = set_make(s1->length);
570 
571     if (s1->length != s2->length)
572@@ -326,8 +334,9 @@
573 Set *
574 set_intersec(ARGIN(const Set *s1), ARGIN(const Set *s2))
575 {
576+    unsigned int i;
577+    ASSERT_ARGS(set_intersec);
578     Set * const  s = set_make(s1->length);
579-    unsigned int i;
580 
581     if (s1->length != s2->length)
582         fatal(1, "set_intersec", "Sets don't have the same length\n");
583@@ -355,6 +364,7 @@
584 set_intersec_inplace(ARGMOD(Set *s1), ARGIN(const Set *s2))
585 {
586     unsigned int i;
587+    ASSERT_ARGS(set_intersec_inplace);
588 
589     if (s1->length != s2->length)
590         fatal(1, "set_intersec_inplace", "Sets don't have the same length\n");