void f(void const *s, int c, unsigned long n) { __e_acsl_store_block((void *)(& s),(size_t)8); unsigned char const *p = (unsigned char const *)s; __e_acsl_store_block((void *)(& p),(size_t)8); __e_acsl_full_init((void *)(& p)); /*@ assert p - (unsigned char const *)s ≡ n - n; */ { __e_acsl_mpz_t __gen_e_acsl_; __e_acsl_mpz_t __gen_e_acsl_n; __e_acsl_mpz_t __gen_e_acsl_sub; int __gen_e_acsl_eq; __gmpz_init_set_ui(__gen_e_acsl_,p - (unsigned char const *)s); __gmpz_init_set_ui(__gen_e_acsl_n,n); __gmpz_init(__gen_e_acsl_sub); __gmpz_sub(__gen_e_acsl_sub, (__e_acsl_mpz_struct const *)(__gen_e_acsl_n), (__e_acsl_mpz_struct const *)(__gen_e_acsl_n)); __gen_e_acsl_eq = __gmpz_cmp((__e_acsl_mpz_struct const *)(__gen_e_acsl_), (__e_acsl_mpz_struct const *)(__gen_e_acsl_sub)); __e_acsl_assert(__gen_e_acsl_eq == 0,(char *)"Assertion",(char *)"f", (char *)"p - (unsigned char const *)s == n - n",16); __gmpz_clear(__gen_e_acsl_); __gmpz_clear(__gen_e_acsl_n); __gmpz_clear(__gen_e_acsl_sub); } /*@ assert p - (unsigned char const *)s ≡ 0; */ __e_acsl_assert(p - (unsigned char const *)s == 0UL,(char *)"Assertion", (char *)"f",(char *)"p - (unsigned char const *)s == 0",17); __e_acsl_delete_block((void *)(& s)); __e_acsl_delete_block((void *)(& p)); return; }
int main(void) { int __retres; __e_acsl_memory_init((int *)0,(char ***)0,(size_t)8); __e_acsl_globals_init(); int i = 4; while (1) { int tmp; tmp = i; /*@ assert Eva: signed_overflow: -2147483648 ≤ i - 1; */ i --; ; if (! tmp) break; { char *s = (char *)__gen_e_acsl_literal_string_3; __e_acsl_store_block((void *)(& s),(size_t)8); __e_acsl_full_init((void *)(& s)); /*@ assert \valid_read(s); */ { int __gen_e_acsl_initialized; int __gen_e_acsl_and; __gen_e_acsl_initialized = __e_acsl_initialized((void *)(& s), sizeof(char *)); if (__gen_e_acsl_initialized) { int __gen_e_acsl_valid_read; __gen_e_acsl_valid_read = __e_acsl_valid_read((void *)s, sizeof(char), (void *)s, (void *)(& s)); __gen_e_acsl_and = __gen_e_acsl_valid_read; } else __gen_e_acsl_and = 0; __e_acsl_assert(__gen_e_acsl_and,(char *)"Assertion",(char *)"main", (char *)"\\valid_read(s)",20); } /*@ assert ¬\valid(s); */ { int __gen_e_acsl_initialized_2; int __gen_e_acsl_and_2; __gen_e_acsl_initialized_2 = __e_acsl_initialized((void *)(& s), sizeof(char *)); if (__gen_e_acsl_initialized_2) { int __gen_e_acsl_valid; __gen_e_acsl_valid = __e_acsl_valid((void *)s,sizeof(char), (void *)s,(void *)(& s)); __gen_e_acsl_and_2 = __gen_e_acsl_valid; } else __gen_e_acsl_and_2 = 0; __e_acsl_assert(! __gen_e_acsl_and_2,(char *)"Assertion", (char *)"main",(char *)"!\\valid(s)",21); __e_acsl_delete_block((void *)(& s)); } } } f(); __retres = 0; __e_acsl_delete_block((void *)(& S)); __e_acsl_memory_clean(); return __retres; }
int f(void) { int __retres; char *s1 = (char *)__gen_e_acsl_literal_string; __e_acsl_store_block((void *)(& s1),(size_t)8); __e_acsl_full_init((void *)(& s1)); char *s2 = (char *)__gen_e_acsl_literal_string_2; __e_acsl_store_block((void *)(& s2),(size_t)8); __e_acsl_full_init((void *)(& s2)); /*@ assert \valid_read(S); */ { int __gen_e_acsl_valid_read; __gen_e_acsl_valid_read = __e_acsl_valid_read((void *)S,sizeof(char), (void *)S,(void *)(& S)); __e_acsl_assert(__gen_e_acsl_valid_read,(char *)"Assertion",(char *)"f", (char *)"\\valid_read(S)",10); } /*@ assert \valid_read(s1); */ { int __gen_e_acsl_initialized; int __gen_e_acsl_and; __gen_e_acsl_initialized = __e_acsl_initialized((void *)(& s1), sizeof(char *)); if (__gen_e_acsl_initialized) { int __gen_e_acsl_valid_read_2; __gen_e_acsl_valid_read_2 = __e_acsl_valid_read((void *)s1, sizeof(char), (void *)s1, (void *)(& s1)); __gen_e_acsl_and = __gen_e_acsl_valid_read_2; } else __gen_e_acsl_and = 0; __e_acsl_assert(__gen_e_acsl_and,(char *)"Assertion",(char *)"f", (char *)"\\valid_read(s1)",11); } /*@ assert \valid_read(s2); */ { int __gen_e_acsl_initialized_2; int __gen_e_acsl_and_2; __gen_e_acsl_initialized_2 = __e_acsl_initialized((void *)(& s2), sizeof(char *)); if (__gen_e_acsl_initialized_2) { int __gen_e_acsl_valid_read_3; __gen_e_acsl_valid_read_3 = __e_acsl_valid_read((void *)s2, sizeof(char), (void *)s2, (void *)(& s2)); __gen_e_acsl_and_2 = __gen_e_acsl_valid_read_3; } else __gen_e_acsl_and_2 = 0; __e_acsl_assert(__gen_e_acsl_and_2,(char *)"Assertion",(char *)"f", (char *)"\\valid_read(s2)",12); } __retres = 0; __e_acsl_delete_block((void *)(& s2)); __e_acsl_delete_block((void *)(& s1)); return __retres; }
int goto_bts(void) { int __retres; int *p; __e_acsl_store_block((void *)(& p),(size_t)8); { int a = 0; __e_acsl_store_block((void *)(& a),(size_t)4); __e_acsl_full_init((void *)(& a)); __e_acsl_full_init((void *)(& p)); p = & a; /*@ assert \valid(p); */ { int __gen_e_acsl_initialized; int __gen_e_acsl_and; __gen_e_acsl_initialized = __e_acsl_initialized((void *)(& p), sizeof(int *)); if (__gen_e_acsl_initialized) { int __gen_e_acsl_valid; __gen_e_acsl_valid = __e_acsl_valid((void *)p,sizeof(int),(void *)p, (void *)(& p)); __gen_e_acsl_and = __gen_e_acsl_valid; } else __gen_e_acsl_and = 0; __e_acsl_assert(__gen_e_acsl_and,(char *)"Assertion", (char *)"goto_bts",(char *)"\\valid(p)",13); } __e_acsl_delete_block((void *)(& a)); goto L; __e_acsl_delete_block((void *)(& a)); } L: /*@ assert ¬\valid(p); */ { int __gen_e_acsl_initialized_2; int __gen_e_acsl_and_2; __gen_e_acsl_initialized_2 = __e_acsl_initialized((void *)(& p), sizeof(int *)); if (__gen_e_acsl_initialized_2) { int __gen_e_acsl_valid_2; /*@ assert Eva: dangling_pointer: ¬\dangling(&p); */ __gen_e_acsl_valid_2 = __e_acsl_valid((void *)p,sizeof(int),(void *)p, (void *)(& p)); __gen_e_acsl_and_2 = __gen_e_acsl_valid_2; } else __gen_e_acsl_and_2 = 0; __e_acsl_assert(! __gen_e_acsl_and_2,(char *)"Assertion", (char *)"goto_bts",(char *)"!\\valid(p)",18); } __retres = 0; __e_acsl_delete_block((void *)(& p)); return __retres; }
int main(void) { int __retres; { int i; i = 0; while (i < 3) { T1[i] = i; i ++; } } { int i_0; i_0 = 0; while (i_0 < 4) { T2[i_0] = 2 * i_0; i_0 ++; } } /*@ assert T1[0] ≡ T2[0]; */ { mpz_t __gen_e_acsl_; mpz_t __gen_e_acsl__2; int __gen_e_acsl_eq; __gmpz_init_set_si(__gen_e_acsl_,(long)T1[0UL]); __gmpz_init_set_si(__gen_e_acsl__2,(long)T2[0UL]); __gen_e_acsl_eq = __gmpz_cmp((__mpz_struct const *)(__gen_e_acsl_), (__mpz_struct const *)(__gen_e_acsl__2)); __e_acsl_assert(__gen_e_acsl_eq == 0,(char *)"Assertion",(char *)"main", (char *)"T1[0] == T2[0]",13); __gmpz_clear(__gen_e_acsl_); __gmpz_clear(__gen_e_acsl__2); } /*@ assert T1[1] ≢ T2[1]; */ { mpz_t __gen_e_acsl__3; mpz_t __gen_e_acsl__4; int __gen_e_acsl_ne; __gmpz_init_set_si(__gen_e_acsl__3,(long)T1[1UL]); __gmpz_init_set_si(__gen_e_acsl__4,(long)T2[1UL]); __gen_e_acsl_ne = __gmpz_cmp((__mpz_struct const *)(__gen_e_acsl__3), (__mpz_struct const *)(__gen_e_acsl__4)); __e_acsl_assert(__gen_e_acsl_ne != 0,(char *)"Assertion",(char *)"main", (char *)"T1[1] != T2[1]",14); __gmpz_clear(__gen_e_acsl__3); __gmpz_clear(__gen_e_acsl__4); } __retres = 0; return __retres; }
void build_tree(tree_desc *desc) { int *extra; __e_acsl_store_block((void *)(& extra),(size_t)8); __e_acsl_store_block((void *)(& desc),(size_t)8); __e_acsl_temporal_pull_parameter((void *)(& desc),0U,8UL); __e_acsl_temporal_store_nreferent((void *)(& extra), (void *)(& desc->extra_bits)); __e_acsl_full_init((void *)(& extra)); extra = desc->extra_bits; /*@ assert \valid(extra); */ { int __gen_e_acsl_initialized; int __gen_e_acsl_and; __gen_e_acsl_initialized = __e_acsl_initialized((void *)(& extra), sizeof(int *)); if (__gen_e_acsl_initialized) { int __gen_e_acsl_valid; __gen_e_acsl_valid = __e_acsl_valid((void *)extra,sizeof(int), (void *)extra,(void *)(& extra)); __gen_e_acsl_and = __gen_e_acsl_valid; } else __gen_e_acsl_and = 0; __e_acsl_assert(__gen_e_acsl_and,(char *)"Assertion", (char *)"build_tree",(char *)"\\valid(extra)",23); } __e_acsl_delete_block((void *)(& desc)); __e_acsl_delete_block((void *)(& extra)); return; }
void f(void const *s, int c, unsigned long n) { __e_acsl_store_block((void *)(& s),(size_t)4); unsigned char const *p = (unsigned char const *)s; __e_acsl_store_block((void *)(& p),(size_t)4); __e_acsl_full_init((void *)(& p)); /*@ assert p - (unsigned char const *)s ≡ n - n; */ __e_acsl_assert(p - (unsigned char const *)s == n - (long long)n, (char *)"Assertion",(char *)"f", (char *)"p - (unsigned char const *)s == n - n",16); /*@ assert p - (unsigned char const *)s ≡ 0; */ __e_acsl_assert(p - (unsigned char const *)s == 0U,(char *)"Assertion", (char *)"f",(char *)"p - (unsigned char const *)s == 0",17); __e_acsl_delete_block((void *)(& s)); __e_acsl_delete_block((void *)(& p)); return; }
/*@ requires \valid(&argc); requires \valid(&argv); */ int main(int argc, char **argv) { int __retres; __e_acsl_memory_init(& argc,& argv,(size_t)8); { int __gen_e_acsl_valid; int __gen_e_acsl_valid_2; __gen_e_acsl_valid = __e_acsl_valid((void *)(& argc),sizeof(int), (void *)(& argc),(void *)0); __e_acsl_assert(__gen_e_acsl_valid,(char *)"Precondition",(char *)"main", (char *)"\\valid(&argc)",7); __gen_e_acsl_valid_2 = __e_acsl_valid((void *)(& argv),sizeof(char **), (void *)(& argv),(void *)0); __e_acsl_assert(__gen_e_acsl_valid_2,(char *)"Precondition", (char *)"main",(char *)"\\valid(&argv)",8); } __retres = __gen_e_acsl_main(argc,argv); __e_acsl_delete_block((void *)(& argv)); __e_acsl_memory_clean(); return __retres; }
/* Generated by Frama-C */ int main(void) { int __retres; long x; int y; x = (long)0; y = 0; /*@ assert (int)x ≡ y; */ __e_acsl_assert((int)x == y,(char *)"Assertion",(char *)"main", (char *)"(int)x == y",10); /*@ assert x ≡ (long)y; */ __e_acsl_assert(x == (long)y,(char *)"Assertion",(char *)"main", (char *)"x == (long)y",11); /*@ assert y ≡ (int)0; */ __e_acsl_assert(y == 0,(char *)"Assertion",(char *)"main", (char *)"y == (int)0",13); /*@ assert (unsigned int)y ≡ (unsigned int)0; */ __e_acsl_assert((unsigned int)y == 0U,(char *)"Assertion",(char *)"main", (char *)"(unsigned int)y == (unsigned int)0",14); /*@ assert y ≢ (int)0xfffffffffffffff; */ __e_acsl_assert(y != -1,(char *)"Assertion",(char *)"main", (char *)"y != (int)0xfffffffffffffff",17); /*@ assert (unsigned int)y ≢ (unsigned int)0xfffffffffffffff; */ __e_acsl_assert((unsigned int)y != 4294967295U,(char *)"Assertion", (char *)"main", (char *)"(unsigned int)y != (unsigned int)0xfffffffffffffff", 18); __retres = 0; return __retres; }
int main(int argc, char const **argv) { int __retres; __e_acsl_memory_init(& argc,(char ***)(& argv),(size_t)8); int a = 1; __e_acsl_store_block((void *)(& a),(size_t)4); __e_acsl_full_init((void *)(& a)); int *p = & a; __e_acsl_store_block((void *)(& p),(size_t)8); __e_acsl_full_init((void *)(& p)); __e_acsl_temporal_store_nblock((void *)(& p),(void *)(& a)); uintptr_t addr = (unsigned long)(& addr); __e_acsl_temporal_reset_parameters(); __e_acsl_temporal_reset_return(); __e_acsl_temporal_save_nreferent_parameter((void *)(& p),1U); __e_acsl_temporal_save_nblock_parameter((void *)(& a),2U); __e_acsl_full_init((void *)(& p)); p = pfun((char)'a',p,& a,(int *)0,(int *)addr,2); __e_acsl_temporal_pull_return((void *)(& p)); /*@ assert \valid(p); */ { int __gen_e_acsl_initialized; int __gen_e_acsl_and; __gen_e_acsl_initialized = __e_acsl_initialized((void *)(& p), sizeof(int *)); if (__gen_e_acsl_initialized) { int __gen_e_acsl_valid; __gen_e_acsl_valid = __e_acsl_valid((void *)p,sizeof(int),(void *)p, (void *)(& p)); __gen_e_acsl_and = __gen_e_acsl_valid; } else __gen_e_acsl_and = 0; __e_acsl_assert(__gen_e_acsl_and,(char *)"Assertion",(char *)"main", (char *)"\\valid(p)",28); } __retres = 0; __e_acsl_delete_block((void *)(& p)); __e_acsl_delete_block((void *)(& a)); __e_acsl_memory_clean(); return __retres; }
int while_valid(void) { int __retres; int *p; int *q; int *r; __e_acsl_store_block((void *)(& r),(size_t)8); __e_acsl_store_block((void *)(& q),(size_t)8); __e_acsl_store_block((void *)(& p),(size_t)8); int i = 5; { int a0 = 0; __e_acsl_store_block((void *)(& a0),(size_t)4); __e_acsl_full_init((void *)(& a0)); __e_acsl_full_init((void *)(& r)); r = & a0; while (1) { i --; if (! i) break; { int a1 = 0; __e_acsl_store_block((void *)(& a1),(size_t)4); __e_acsl_full_init((void *)(& a1)); __e_acsl_full_init((void *)(& p)); p = & a1; { int a2 = 0; __e_acsl_store_block((void *)(& a2),(size_t)4); __e_acsl_full_init((void *)(& a2)); __e_acsl_full_init((void *)(& q)); q = & a2; /*@ assert \valid(p); */ { int __gen_e_acsl_initialized; int __gen_e_acsl_and; __gen_e_acsl_initialized = __e_acsl_initialized((void *)(& p), sizeof(int *)); if (__gen_e_acsl_initialized) { int __gen_e_acsl_valid; __gen_e_acsl_valid = __e_acsl_valid((void *)p,sizeof(int), (void *)p,(void *)(& p)); __gen_e_acsl_and = __gen_e_acsl_valid; } else __gen_e_acsl_and = 0; __e_acsl_assert(__gen_e_acsl_and,(char *)"Assertion", (char *)"while_valid",(char *)"\\valid(p)",108); } /*@ assert \valid(q); */ { int __gen_e_acsl_initialized_2; int __gen_e_acsl_and_2; __gen_e_acsl_initialized_2 = __e_acsl_initialized((void *)(& q), sizeof(int *)); if (__gen_e_acsl_initialized_2) { int __gen_e_acsl_valid_2; __gen_e_acsl_valid_2 = __e_acsl_valid((void *)q,sizeof(int), (void *)q,(void *)(& q)); __gen_e_acsl_and_2 = __gen_e_acsl_valid_2; } else __gen_e_acsl_and_2 = 0; __e_acsl_assert(__gen_e_acsl_and_2,(char *)"Assertion", (char *)"while_valid",(char *)"\\valid(q)",109); } /*@ assert \valid(r); */ { int __gen_e_acsl_initialized_3; int __gen_e_acsl_and_3; __gen_e_acsl_initialized_3 = __e_acsl_initialized((void *)(& r), sizeof(int *)); if (__gen_e_acsl_initialized_3) { int __gen_e_acsl_valid_3; __gen_e_acsl_valid_3 = __e_acsl_valid((void *)r,sizeof(int), (void *)r,(void *)(& r)); __gen_e_acsl_and_3 = __gen_e_acsl_valid_3; } else __gen_e_acsl_and_3 = 0; __e_acsl_assert(__gen_e_acsl_and_3,(char *)"Assertion", (char *)"while_valid",(char *)"\\valid(r)",110); } if (! i) { __e_acsl_delete_block((void *)(& a1)); __e_acsl_delete_block((void *)(& a2)); break; } __e_acsl_delete_block((void *)(& a2)); __e_acsl_delete_block((void *)(& a1)); } } } /*@ assert ¬\valid(p); */ { int __gen_e_acsl_initialized_4; int __gen_e_acsl_and_4; __gen_e_acsl_initialized_4 = __e_acsl_initialized((void *)(& p), sizeof(int *)); if (__gen_e_acsl_initialized_4) { int __gen_e_acsl_valid_4; __gen_e_acsl_valid_4 = __e_acsl_valid((void *)p,sizeof(int), (void *)p,(void *)(& p)); __gen_e_acsl_and_4 = __gen_e_acsl_valid_4; } else __gen_e_acsl_and_4 = 0; __e_acsl_assert(! __gen_e_acsl_and_4,(char *)"Assertion", (char *)"while_valid",(char *)"!\\valid(p)",116); } /*@ assert ¬\valid(q); */ { int __gen_e_acsl_initialized_5; int __gen_e_acsl_and_5; __gen_e_acsl_initialized_5 = __e_acsl_initialized((void *)(& q), sizeof(int *)); if (__gen_e_acsl_initialized_5) { int __gen_e_acsl_valid_5; __gen_e_acsl_valid_5 = __e_acsl_valid((void *)q,sizeof(int), (void *)q,(void *)(& q)); __gen_e_acsl_and_5 = __gen_e_acsl_valid_5; } else __gen_e_acsl_and_5 = 0; __e_acsl_assert(! __gen_e_acsl_and_5,(char *)"Assertion", (char *)"while_valid",(char *)"!\\valid(q)",117); } /*@ assert \valid(r); */ { int __gen_e_acsl_initialized_6; int __gen_e_acsl_and_6; __gen_e_acsl_initialized_6 = __e_acsl_initialized((void *)(& r), sizeof(int *)); if (__gen_e_acsl_initialized_6) { int __gen_e_acsl_valid_6; __gen_e_acsl_valid_6 = __e_acsl_valid((void *)r,sizeof(int), (void *)r,(void *)(& r)); __gen_e_acsl_and_6 = __gen_e_acsl_valid_6; } else __gen_e_acsl_and_6 = 0; __e_acsl_assert(__gen_e_acsl_and_6,(char *)"Assertion", (char *)"while_valid",(char *)"\\valid(r)",118); __e_acsl_delete_block((void *)(& a0)); } } __retres = 0; __e_acsl_delete_block((void *)(& r)); __e_acsl_delete_block((void *)(& q)); __e_acsl_delete_block((void *)(& p)); return __retres; }
/*@ ensures *\old(AverageAccel) ≡ (((((*\old(Accel))[4] + (*\old(Accel))[3]) + (*\old(Accel))[2]) + (*\old(Accel))[1]) + (*\old(Accel))[0]) / 5; */ void __gen_e_acsl_atp_NORMAL_computeAverageAccel(ArrayInt *Accel, int *AverageAccel) { ArrayInt *__gen_e_acsl_at_6; ArrayInt *__gen_e_acsl_at_5; ArrayInt *__gen_e_acsl_at_4; ArrayInt *__gen_e_acsl_at_3; ArrayInt *__gen_e_acsl_at_2; int *__gen_e_acsl_at; __gen_e_acsl_at_6 = Accel; __gen_e_acsl_at_5 = Accel; __gen_e_acsl_at_4 = Accel; __gen_e_acsl_at_3 = Accel; __gen_e_acsl_at_2 = Accel; __gen_e_acsl_at = AverageAccel; __e_acsl_store_block((void *)(& AverageAccel),(size_t)8); __e_acsl_store_block((void *)(& Accel),(size_t)8); atp_NORMAL_computeAverageAccel(Accel,AverageAccel); { int __gen_e_acsl_valid_read; int __gen_e_acsl_valid_read_2; int __gen_e_acsl_valid_read_3; int __gen_e_acsl_valid_read_4; int __gen_e_acsl_valid_read_5; int __gen_e_acsl_valid_read_6; __gen_e_acsl_valid_read = __e_acsl_valid_read((void *)(*__gen_e_acsl_at_6), sizeof(int), (void *)(*__gen_e_acsl_at_6), (void *)(*__gen_e_acsl_at_6)); __e_acsl_assert(__gen_e_acsl_valid_read,(char *)"RTE", (char *)"atp_NORMAL_computeAverageAccel", (char *)"mem_access: \\valid_read((int *)*__gen_e_acsl_at_6)", 8); __gen_e_acsl_valid_read_2 = __e_acsl_valid_read((void *)(& (*__gen_e_acsl_at_5)[1]), sizeof(int), (void *)(& (*__gen_e_acsl_at_5)[1]), (void *)0); __e_acsl_assert(__gen_e_acsl_valid_read_2,(char *)"RTE", (char *)"atp_NORMAL_computeAverageAccel", (char *)"mem_access: \\valid_read(&(*__gen_e_acsl_at_5)[1])", 8); __gen_e_acsl_valid_read_3 = __e_acsl_valid_read((void *)(& (*__gen_e_acsl_at_4)[2]), sizeof(int), (void *)(& (*__gen_e_acsl_at_4)[2]), (void *)0); __e_acsl_assert(__gen_e_acsl_valid_read_3,(char *)"RTE", (char *)"atp_NORMAL_computeAverageAccel", (char *)"mem_access: \\valid_read(&(*__gen_e_acsl_at_4)[2])", 8); __gen_e_acsl_valid_read_4 = __e_acsl_valid_read((void *)(& (*__gen_e_acsl_at_3)[3]), sizeof(int), (void *)(& (*__gen_e_acsl_at_3)[3]), (void *)0); __e_acsl_assert(__gen_e_acsl_valid_read_4,(char *)"RTE", (char *)"atp_NORMAL_computeAverageAccel", (char *)"mem_access: \\valid_read(&(*__gen_e_acsl_at_3)[3])", 8); __gen_e_acsl_valid_read_5 = __e_acsl_valid_read((void *)(& (*__gen_e_acsl_at_2)[4]), sizeof(int), (void *)(& (*__gen_e_acsl_at_2)[4]), (void *)0); __e_acsl_assert(__gen_e_acsl_valid_read_5,(char *)"RTE", (char *)"atp_NORMAL_computeAverageAccel", (char *)"mem_access: \\valid_read(&(*__gen_e_acsl_at_2)[4])", 8); __gen_e_acsl_valid_read_6 = __e_acsl_valid_read((void *)__gen_e_acsl_at, sizeof(int), (void *)__gen_e_acsl_at, (void *)(& __gen_e_acsl_at)); __e_acsl_assert(__gen_e_acsl_valid_read_6,(char *)"RTE", (char *)"atp_NORMAL_computeAverageAccel", (char *)"mem_access: \\valid_read(__gen_e_acsl_at)",8); __e_acsl_assert(*__gen_e_acsl_at == (int)((((((*__gen_e_acsl_at_2)[4] + (long)(*__gen_e_acsl_at_3)[3]) + (*__gen_e_acsl_at_4)[2]) + (*__gen_e_acsl_at_5)[1]) + (*__gen_e_acsl_at_6)[0]) / 5L), (char *)"Postcondition", (char *)"atp_NORMAL_computeAverageAccel", (char *)"*\\old(AverageAccel) ==\n(((((*\\old(Accel))[4] + (*\\old(Accel))[3]) + (*\\old(Accel))[2]) +\n (*\\old(Accel))[1])\n + (*\\old(Accel))[0])\n/ 5", 8); __e_acsl_delete_block((void *)(& AverageAccel)); __e_acsl_delete_block((void *)(& Accel)); return; } }
int main(int argc, char **argv) { int __retres; __e_acsl_memory_init(& argc,& argv,(size_t)8); __e_acsl_globals_init(); int *p = (int *)0; __e_acsl_store_block((void *)(& p),(size_t)8); __e_acsl_full_init((void *)(& p)); int *q = (int *)0; int a = 1; int b = 2; __e_acsl_store_block((void *)(& b),(size_t)4); __e_acsl_full_init((void *)(& b)); int c = 3; __e_acsl_full_init((void *)(& p)); p = & b; /*@ assert \valid(p); */ { int __gen_e_acsl_initialized; int __gen_e_acsl_and; __gen_e_acsl_initialized = __e_acsl_initialized((void *)(& p), sizeof(int *)); if (__gen_e_acsl_initialized) { int __gen_e_acsl_valid; __gen_e_acsl_valid = __e_acsl_valid((void *)p,sizeof(int),(void *)p, (void *)(& p)); __gen_e_acsl_and = __gen_e_acsl_valid; } else __gen_e_acsl_and = 0; __e_acsl_assert(__gen_e_acsl_and,(char *)"Assertion",(char *)"main", (char *)"\\valid(p)",24); } /*@ assert ¬\valid(p + 1); */ { int __gen_e_acsl_valid_2; __gen_e_acsl_valid_2 = __e_acsl_valid((void *)(p + 1),sizeof(int), (void *)p,(void *)(& p)); __e_acsl_assert(! __gen_e_acsl_valid_2,(char *)"Assertion", (char *)"main",(char *)"!\\valid(p + 1)",26); } __e_acsl_full_init((void *)(& p)); p = & B; /*@ assert \valid(p); */ { int __gen_e_acsl_initialized_2; int __gen_e_acsl_and_2; __gen_e_acsl_initialized_2 = __e_acsl_initialized((void *)(& p), sizeof(int *)); if (__gen_e_acsl_initialized_2) { int __gen_e_acsl_valid_3; __gen_e_acsl_valid_3 = __e_acsl_valid((void *)p,sizeof(int),(void *)p, (void *)(& p)); __gen_e_acsl_and_2 = __gen_e_acsl_valid_3; } else __gen_e_acsl_and_2 = 0; __e_acsl_assert(__gen_e_acsl_and_2,(char *)"Assertion",(char *)"main", (char *)"\\valid(p)",29); } /*@ assert ¬\valid(p + 1); */ { int __gen_e_acsl_valid_4; __gen_e_acsl_valid_4 = __e_acsl_valid((void *)(p + 1),sizeof(int), (void *)p,(void *)(& p)); __e_acsl_assert(! __gen_e_acsl_valid_4,(char *)"Assertion", (char *)"main",(char *)"!\\valid(p + 1)",31); } char *pmin = malloc(sizeof(int)); __e_acsl_store_block((void *)(& pmin),(size_t)8); __e_acsl_full_init((void *)(& pmin)); char *pmax = malloc(sizeof(int)); __e_acsl_store_block((void *)(& pmax),(size_t)8); __e_acsl_full_init((void *)(& pmax)); if ((unsigned long)pmin > (unsigned long)pmax) { char *t = pmin; __e_acsl_store_block((void *)(& t),(size_t)8); __e_acsl_full_init((void *)(& t)); __e_acsl_full_init((void *)(& pmin)); pmin = pmax; __e_acsl_full_init((void *)(& pmax)); pmax = t; __e_acsl_delete_block((void *)(& t)); } __e_acsl_initialize((void *)pmin,sizeof(char)); /*@ assert Eva: mem_access: \valid(pmin); */ *pmin = (char)'P'; __e_acsl_initialize((void *)pmax,sizeof(char)); /*@ assert Eva: mem_access: \valid(pmax); */ *pmax = (char)'L'; int diff = (int)((unsigned long)pmax - (unsigned long)pmin); /*@ assert \valid(pmin); */ { int __gen_e_acsl_initialized_3; int __gen_e_acsl_and_3; __gen_e_acsl_initialized_3 = __e_acsl_initialized((void *)(& pmin), sizeof(char *)); if (__gen_e_acsl_initialized_3) { int __gen_e_acsl_valid_5; __gen_e_acsl_valid_5 = __e_acsl_valid((void *)pmin,sizeof(char), (void *)pmin,(void *)(& pmin)); __gen_e_acsl_and_3 = __gen_e_acsl_valid_5; } else __gen_e_acsl_and_3 = 0; __e_acsl_assert(__gen_e_acsl_and_3,(char *)"Assertion",(char *)"main", (char *)"\\valid(pmin)",49); } /*@ assert \valid(pmax); */ { int __gen_e_acsl_initialized_4; int __gen_e_acsl_and_4; __gen_e_acsl_initialized_4 = __e_acsl_initialized((void *)(& pmax), sizeof(char *)); if (__gen_e_acsl_initialized_4) { int __gen_e_acsl_valid_6; __gen_e_acsl_valid_6 = __e_acsl_valid((void *)pmax,sizeof(char), (void *)pmax,(void *)(& pmax)); __gen_e_acsl_and_4 = __gen_e_acsl_valid_6; } else __gen_e_acsl_and_4 = 0; __e_acsl_assert(__gen_e_acsl_and_4,(char *)"Assertion",(char *)"main", (char *)"\\valid(pmax)",50); } /*@ assert ¬\valid(pmin + diff); */ { int __gen_e_acsl_valid_7; __gen_e_acsl_valid_7 = __e_acsl_valid((void *)(pmin + diff),sizeof(char), (void *)pmin,(void *)(& pmin)); __e_acsl_assert(! __gen_e_acsl_valid_7,(char *)"Assertion", (char *)"main",(char *)"!\\valid(pmin + diff)",52); } /*@ assert ¬\valid(pmax - diff); */ { int __gen_e_acsl_valid_8; __gen_e_acsl_valid_8 = __e_acsl_valid((void *)(pmax - diff),sizeof(char), (void *)pmax,(void *)(& pmax)); __e_acsl_assert(! __gen_e_acsl_valid_8,(char *)"Assertion", (char *)"main",(char *)"!\\valid(pmax - diff)",54); } __retres = 0; __e_acsl_delete_block((void *)(& B)); __e_acsl_delete_block((void *)(& pmax)); __e_acsl_delete_block((void *)(& pmin)); __e_acsl_delete_block((void *)(& b)); __e_acsl_delete_block((void *)(& p)); __e_acsl_memory_clean(); return __retres; }
int main(void) { int __retres; __e_acsl_memory_init((int *)0,(char ***)0,(size_t)8); int x = 0; int y = 1; /*@ assert x < y; */ __e_acsl_assert(x < y,(char *)"Assertion",(char *)"main",(char *)"x < y",7); /*@ assert y > x; */ __e_acsl_assert(y > x,(char *)"Assertion",(char *)"main",(char *)"y > x",8); /*@ assert x ≤ 0; */ __e_acsl_assert(x <= 0,(char *)"Assertion",(char *)"main",(char *)"x <= 0", 9); /*@ assert y ≥ 1; */ __e_acsl_assert(y >= 1,(char *)"Assertion",(char *)"main",(char *)"y >= 1", 10); char *s = (char *)"toto"; /*@ assert s ≡ s; */ __e_acsl_assert(s == s,(char *)"Assertion",(char *)"main",(char *)"s == s", 12); /*@ assert 5 < 18; */ __e_acsl_assert(1,(char *)"Assertion",(char *)"main",(char *)"5 < 18",15); /*@ assert 32 > 3; */ __e_acsl_assert(1,(char *)"Assertion",(char *)"main",(char *)"32 > 3",16); /*@ assert 12 ≤ 13; */ __e_acsl_assert(1,(char *)"Assertion",(char *)"main",(char *)"12 <= 13",17); /*@ assert 123 ≥ 12; */ __e_acsl_assert(1,(char *)"Assertion",(char *)"main",(char *)"123 >= 12", 18); /*@ assert 0xff ≡ 0xff; */ __e_acsl_assert(1,(char *)"Assertion",(char *)"main", (char *)"0xff == 0xff",19); /*@ assert 1 ≢ 2; */ __e_acsl_assert(1,(char *)"Assertion",(char *)"main",(char *)"1 != 2",20); /*@ assert -5 < 18; */ __e_acsl_assert(1,(char *)"Assertion",(char *)"main",(char *)"-5 < 18",22); /*@ assert 32 > -3; */ __e_acsl_assert(1,(char *)"Assertion",(char *)"main",(char *)"32 > -3",23); /*@ assert -12 ≤ 13; */ __e_acsl_assert(1,(char *)"Assertion",(char *)"main",(char *)"-12 <= 13", 24); /*@ assert 123 ≥ -12; */ __e_acsl_assert(1,(char *)"Assertion",(char *)"main",(char *)"123 >= -12", 25); /*@ assert -0xff ≡ -0xff; */ __e_acsl_assert(1,(char *)"Assertion",(char *)"main", (char *)"-0xff == -0xff",26); /*@ assert 1 ≢ -2; */ __e_acsl_assert(1,(char *)"Assertion",(char *)"main",(char *)"1 != -2",27); __retres = 0; return __retres; }
/* compiler builtin: void *__builtin_alloca(unsigned long); */ void test_specifier_application(char const *allowed, char const *fmt, int only_negative, char *at) { size_t tmp; unsigned long __lengthof_format; __e_acsl_store_block((void *)(& __lengthof_format),(size_t)8); __e_acsl_store_block((void *)(& tmp),(size_t)8); __e_acsl_store_block((void *)(& at),(size_t)8); __e_acsl_store_block((void *)(& only_negative),(size_t)4); __e_acsl_store_block((void *)(& fmt),(size_t)8); __e_acsl_store_block((void *)(& allowed),(size_t)8); __e_acsl_full_init((void *)(& tmp)); tmp = __gen_e_acsl_strlen(fmt); int len = (int)tmp; __e_acsl_store_block((void *)(& len),(size_t)4); __e_acsl_full_init((void *)(& len)); /*@ assert alloca_bounds: 0 < sizeof(char) * (len + 1) ≤ 18446744073709551615; */ { int __gen_e_acsl_and; if (0L < 1L * (len + 1L)) { __e_acsl_mpz_t __gen_e_acsl_; __e_acsl_mpz_t __gen_e_acsl__2; int __gen_e_acsl_le; __gmpz_init_set_si(__gen_e_acsl_,1L * (len + 1L)); __gmpz_init_set_ui(__gen_e_acsl__2,18446744073709551615UL); __gen_e_acsl_le = __gmpz_cmp((__e_acsl_mpz_struct const *)(__gen_e_acsl_), (__e_acsl_mpz_struct const *)(__gen_e_acsl__2)); __gen_e_acsl_and = __gen_e_acsl_le <= 0; __gmpz_clear(__gen_e_acsl_); __gmpz_clear(__gen_e_acsl__2); } else __gen_e_acsl_and = 0; __e_acsl_assert(__gen_e_acsl_and,(char *)"Assertion", (char *)"test_specifier_application", (char *)"alloca_bounds: 0 < sizeof(char) * (len + 1) <= 18446744073709551615", 82); } __e_acsl_full_init((void *)(& __lengthof_format)); __lengthof_format = (unsigned long)(len + 1); char *format = __builtin_alloca(sizeof(char) * __lengthof_format); __e_acsl_store_block((void *)format,sizeof(char) * __lengthof_format); __e_acsl_store_block((void *)(& format),(size_t)8); __e_acsl_full_init((void *)(& format)); __gen_e_acsl_strcpy(format,fmt); { int i_0 = 0; __e_acsl_store_block((void *)(& i_0),(size_t)4); __e_acsl_full_init((void *)(& i_0)); while (1) { size_t tmp_3; __e_acsl_store_block((void *)(& tmp_3),(size_t)8); __e_acsl_full_init((void *)(& tmp_3)); tmp_3 = __gen_e_acsl_strlen(valid_specifiers); ; if (! ((size_t)i_0 < tmp_3)) { __e_acsl_delete_block((void *)(& tmp_3)); break; } { char *tmp_2; __e_acsl_store_block((void *)(& tmp_2),(size_t)8); int c = (int)*(valid_specifiers + i_0); __e_acsl_store_block((void *)(& c),(size_t)4); __e_acsl_full_init((void *)(& c)); __e_acsl_initialize((void *)(format + (len - 1)),sizeof(char)); *(format + (len - 1)) = (char)c; __e_acsl_full_init((void *)(& tmp_2)); tmp_2 = __gen_e_acsl_strchr(allowed,c); if (tmp_2) { if (! only_negative) { { pid_t pid = fork(); __e_acsl_store_block((void *)(& pid),(size_t)4); __e_acsl_full_init((void *)(& pid)); if (! pid) { apply_specifier(format,c); __gen_e_acsl_exit(0); } else { int process_status; __e_acsl_store_block((void *)(& process_status),(size_t)4); waitpid(pid,& process_status,0); signal_eval(process_status,0,(char const *)at); __e_acsl_delete_block((void *)(& process_status)); } __e_acsl_delete_block((void *)(& pid)); } } } else { { pid_t pid_0 = fork(); __e_acsl_store_block((void *)(& pid_0),(size_t)4); __e_acsl_full_init((void *)(& pid_0)); if (! pid_0) { apply_specifier(format,c); __gen_e_acsl_exit(0); } else { int process_status_0; __e_acsl_store_block((void *)(& process_status_0),(size_t)4); waitpid(pid_0,& process_status_0,0); signal_eval(process_status_0,1,(char const *)at); __e_acsl_delete_block((void *)(& process_status_0)); } __e_acsl_delete_block((void *)(& pid_0)); } } __e_acsl_delete_block((void *)(& tmp_2)); __e_acsl_delete_block((void *)(& c)); } __e_acsl_full_init((void *)(& i_0)); i_0 ++; __e_acsl_delete_block((void *)(& tmp_3)); } __e_acsl_delete_block((void *)(& i_0)); } __e_acsl_delete_block((void *)format); __e_acsl_delete_block((void *)(& at)); __e_acsl_delete_block((void *)(& only_negative)); __e_acsl_delete_block((void *)(& fmt)); __e_acsl_delete_block((void *)(& allowed)); __e_acsl_delete_block((void *)(& __lengthof_format)); __e_acsl_delete_block((void *)(& format)); __e_acsl_delete_block((void *)(& tmp)); __e_acsl_delete_block((void *)(& len)); return; }
int main(void) { int __retres; temporal t1; temporal t2; temporal *tp; temporal tarr[2]; larger l; larger *lp; larger larr[2]; __e_acsl_memory_init((int *)0,(char ***)0,(size_t)8); __e_acsl_store_block((void *)(larr),(size_t)64); __e_acsl_store_block((void *)(& lp),(size_t)8); __e_acsl_store_block((void *)(& l),(size_t)32); __e_acsl_store_block((void *)(tarr),(size_t)32); __e_acsl_store_block((void *)(& t2),(size_t)16); __e_acsl_store_block((void *)(& t1),(size_t)16); int a = 1; __e_acsl_store_block((void *)(& a),(size_t)4); __e_acsl_full_init((void *)(& a)); int b = 2; __e_acsl_temporal_store_nblock((void *)(& t1.p),(void *)(& a)); __e_acsl_initialize((void *)(& t1.p),sizeof(char *)); t1.p = (char *)(& a); __e_acsl_temporal_store_nreferent((void *)(& t1.q),(void *)(& t1.p)); __e_acsl_initialize((void *)(& t1.q),sizeof(char *)); t1.q = t1.p; /*@ assert \valid(t1.p) ∧ \valid(t1.q); */ { int __gen_e_acsl_initialized; int __gen_e_acsl_and; int __gen_e_acsl_and_3; __gen_e_acsl_initialized = __e_acsl_initialized((void *)(& t1.p), sizeof(char *)); if (__gen_e_acsl_initialized) { int __gen_e_acsl_valid; __gen_e_acsl_valid = __e_acsl_valid((void *)t1.p,sizeof(char), (void *)t1.p,(void *)(& t1.p)); __gen_e_acsl_and = __gen_e_acsl_valid; } else __gen_e_acsl_and = 0; if (__gen_e_acsl_and) { int __gen_e_acsl_initialized_2; int __gen_e_acsl_and_2; __gen_e_acsl_initialized_2 = __e_acsl_initialized((void *)(& t1.q), sizeof(char *)); if (__gen_e_acsl_initialized_2) { int __gen_e_acsl_valid_2; __gen_e_acsl_valid_2 = __e_acsl_valid((void *)t1.q,sizeof(char), (void *)t1.q,(void *)(& t1.q)); __gen_e_acsl_and_2 = __gen_e_acsl_valid_2; } else __gen_e_acsl_and_2 = 0; __gen_e_acsl_and_3 = __gen_e_acsl_and_2; } else __gen_e_acsl_and_3 = 0; __e_acsl_assert(__gen_e_acsl_and_3,(char *)"Assertion",(char *)"main", (char *)"\\valid(t1.p) && \\valid(t1.q)",31); } /*@ assert ¬\valid(t2.p) ∧ ¬\valid(t2.q); */ { int __gen_e_acsl_initialized_3; int __gen_e_acsl_and_4; int __gen_e_acsl_and_6; __gen_e_acsl_initialized_3 = __e_acsl_initialized((void *)(& t2.p), sizeof(char *)); if (__gen_e_acsl_initialized_3) { int __gen_e_acsl_valid_3; __gen_e_acsl_valid_3 = __e_acsl_valid((void *)t2.p,sizeof(char), (void *)t2.p,(void *)(& t2.p)); __gen_e_acsl_and_4 = __gen_e_acsl_valid_3; } else __gen_e_acsl_and_4 = 0; if (! __gen_e_acsl_and_4) { int __gen_e_acsl_initialized_4; int __gen_e_acsl_and_5; __gen_e_acsl_initialized_4 = __e_acsl_initialized((void *)(& t2.q), sizeof(char *)); if (__gen_e_acsl_initialized_4) { int __gen_e_acsl_valid_4; __gen_e_acsl_valid_4 = __e_acsl_valid((void *)t2.q,sizeof(char), (void *)t2.q,(void *)(& t2.q)); __gen_e_acsl_and_5 = __gen_e_acsl_valid_4; } else __gen_e_acsl_and_5 = 0; __gen_e_acsl_and_6 = ! __gen_e_acsl_and_5; } else __gen_e_acsl_and_6 = 0; __e_acsl_assert(__gen_e_acsl_and_6,(char *)"Assertion",(char *)"main", (char *)"!\\valid(t2.p) && !\\valid(t2.q)",32); } __e_acsl_temporal_memcpy((void *)(& t2),(void *)(& t1),(size_t)16); __e_acsl_full_init((void *)(& t2)); t2 = t1; /*@ assert \valid(t2.p) ∧ \valid(t2.q); */ { int __gen_e_acsl_initialized_5; int __gen_e_acsl_and_7; int __gen_e_acsl_and_9; __gen_e_acsl_initialized_5 = __e_acsl_initialized((void *)(& t2.p), sizeof(char *)); if (__gen_e_acsl_initialized_5) { int __gen_e_acsl_valid_5; __gen_e_acsl_valid_5 = __e_acsl_valid((void *)t2.p,sizeof(char), (void *)t2.p,(void *)(& t2.p)); __gen_e_acsl_and_7 = __gen_e_acsl_valid_5; } else __gen_e_acsl_and_7 = 0; if (__gen_e_acsl_and_7) { int __gen_e_acsl_initialized_6; int __gen_e_acsl_and_8; __gen_e_acsl_initialized_6 = __e_acsl_initialized((void *)(& t2.q), sizeof(char *)); if (__gen_e_acsl_initialized_6) { int __gen_e_acsl_valid_6; __gen_e_acsl_valid_6 = __e_acsl_valid((void *)t2.q,sizeof(char), (void *)t2.q,(void *)(& t2.q)); __gen_e_acsl_and_8 = __gen_e_acsl_valid_6; } else __gen_e_acsl_and_8 = 0; __gen_e_acsl_and_9 = __gen_e_acsl_and_8; } else __gen_e_acsl_and_9 = 0; __e_acsl_assert(__gen_e_acsl_and_9,(char *)"Assertion",(char *)"main", (char *)"\\valid(t2.p) && \\valid(t2.q)",35); } __e_acsl_temporal_store_nblock((void *)(& t2.p),(void *)0); __e_acsl_initialize((void *)(& t2.p),sizeof(char *)); t2.p = (char *)0; __e_acsl_temporal_reset_parameters(); __e_acsl_temporal_reset_return(); __e_acsl_initialize((void *)(& t2.q),sizeof(char *)); t2.q = (char *)malloc((unsigned long)4); __e_acsl_temporal_store_nblock((void *)(& t2.q),(void *)*(& t2.q)); /*@ assert ¬\valid(t2.p) ∧ \valid(t2.q); */ { int __gen_e_acsl_initialized_7; int __gen_e_acsl_and_10; int __gen_e_acsl_and_12; __gen_e_acsl_initialized_7 = __e_acsl_initialized((void *)(& t2.p), sizeof(char *)); if (__gen_e_acsl_initialized_7) { int __gen_e_acsl_valid_7; __gen_e_acsl_valid_7 = __e_acsl_valid((void *)t2.p,sizeof(char), (void *)t2.p,(void *)(& t2.p)); __gen_e_acsl_and_10 = __gen_e_acsl_valid_7; } else __gen_e_acsl_and_10 = 0; if (! __gen_e_acsl_and_10) { int __gen_e_acsl_initialized_8; int __gen_e_acsl_and_11; __gen_e_acsl_initialized_8 = __e_acsl_initialized((void *)(& t2.q), sizeof(char *)); if (__gen_e_acsl_initialized_8) { int __gen_e_acsl_valid_8; __gen_e_acsl_valid_8 = __e_acsl_valid((void *)t2.q,sizeof(char), (void *)t2.q,(void *)(& t2.q)); __gen_e_acsl_and_11 = __gen_e_acsl_valid_8; } else __gen_e_acsl_and_11 = 0; __gen_e_acsl_and_12 = __gen_e_acsl_and_11; } else __gen_e_acsl_and_12 = 0; __e_acsl_assert(__gen_e_acsl_and_12,(char *)"Assertion",(char *)"main", (char *)"!\\valid(t2.p) && \\valid(t2.q)",39); } __e_acsl_temporal_memcpy((void *)(& l.t),(void *)(& t2),(size_t)16); __e_acsl_initialize((void *)(& l.t),sizeof(struct temporal_t)); l.t = t2; /*@ assert ¬\valid(l.t.p) ∧ \valid(l.t.q); */ { int __gen_e_acsl_initialized_9; int __gen_e_acsl_and_13; int __gen_e_acsl_and_15; __gen_e_acsl_initialized_9 = __e_acsl_initialized((void *)(& l.t.p), sizeof(char *)); if (__gen_e_acsl_initialized_9) { int __gen_e_acsl_valid_9; __gen_e_acsl_valid_9 = __e_acsl_valid((void *)l.t.p,sizeof(char), (void *)l.t.p,(void *)(& l.t.p)); __gen_e_acsl_and_13 = __gen_e_acsl_valid_9; } else __gen_e_acsl_and_13 = 0; if (! __gen_e_acsl_and_13) { int __gen_e_acsl_initialized_10; int __gen_e_acsl_and_14; __gen_e_acsl_initialized_10 = __e_acsl_initialized((void *)(& l.t.q), sizeof(char *)); if (__gen_e_acsl_initialized_10) { int __gen_e_acsl_valid_10; __gen_e_acsl_valid_10 = __e_acsl_valid((void *)l.t.q,sizeof(char), (void *)l.t.q, (void *)(& l.t.q)); __gen_e_acsl_and_14 = __gen_e_acsl_valid_10; } else __gen_e_acsl_and_14 = 0; __gen_e_acsl_and_15 = __gen_e_acsl_and_14; } else __gen_e_acsl_and_15 = 0; __e_acsl_assert(__gen_e_acsl_and_15,(char *)"Assertion",(char *)"main", (char *)"!\\valid(l.t.p) && \\valid(l.t.q)",42); } __e_acsl_temporal_store_nblock((void *)(& lp),(void *)(& l)); __e_acsl_full_init((void *)(& lp)); lp = & l; /*@ assert ¬\valid(lp->t.p); */ { int __gen_e_acsl_initialized_11; int __gen_e_acsl_and_16; __gen_e_acsl_initialized_11 = __e_acsl_initialized((void *)(& lp->t.p), sizeof(char *)); if (__gen_e_acsl_initialized_11) { int __gen_e_acsl_valid_read; int __gen_e_acsl_valid_11; __gen_e_acsl_valid_read = __e_acsl_valid_read((void *)(& lp->t.p), sizeof(char *), (void *)(& lp->t.p), (void *)0); __e_acsl_assert(__gen_e_acsl_valid_read,(char *)"RTE",(char *)"main", (char *)"mem_access: \\valid_read(&lp->t.p)",45); __gen_e_acsl_valid_11 = __e_acsl_valid((void *)lp->t.p,sizeof(char), (void *)lp->t.p, (void *)(& lp->t.p)); __gen_e_acsl_and_16 = __gen_e_acsl_valid_11; } else __gen_e_acsl_and_16 = 0; __e_acsl_assert(! __gen_e_acsl_and_16,(char *)"Assertion",(char *)"main", (char *)"!\\valid(lp->t.p)",45); } __e_acsl_temporal_memcpy((void *)(tarr),(void *)(& t2),(size_t)16); __e_acsl_initialize((void *)(tarr),sizeof(temporal)); tarr[0] = t2; /*@ assert ¬\valid(tarr[0].p) ∧ \valid(tarr[0].q); */ { int __gen_e_acsl_initialized_12; int __gen_e_acsl_and_17; int __gen_e_acsl_and_19; __gen_e_acsl_initialized_12 = __e_acsl_initialized((void *)(& tarr[0].p), sizeof(char *)); if (__gen_e_acsl_initialized_12) { int __gen_e_acsl_valid_12; __gen_e_acsl_valid_12 = __e_acsl_valid((void *)tarr[0].p,sizeof(char), (void *)tarr[0].p, (void *)(& tarr[0].p)); __gen_e_acsl_and_17 = __gen_e_acsl_valid_12; } else __gen_e_acsl_and_17 = 0; if (! __gen_e_acsl_and_17) { int __gen_e_acsl_initialized_13; int __gen_e_acsl_and_18; __gen_e_acsl_initialized_13 = __e_acsl_initialized((void *)(& tarr[0].q), sizeof(char *)); if (__gen_e_acsl_initialized_13) { int __gen_e_acsl_valid_13; __gen_e_acsl_valid_13 = __e_acsl_valid((void *)tarr[0].q, sizeof(char), (void *)tarr[0].q, (void *)(& tarr[0].q)); __gen_e_acsl_and_18 = __gen_e_acsl_valid_13; } else __gen_e_acsl_and_18 = 0; __gen_e_acsl_and_19 = __gen_e_acsl_and_18; } else __gen_e_acsl_and_19 = 0; __e_acsl_assert(__gen_e_acsl_and_19,(char *)"Assertion",(char *)"main", (char *)"!\\valid(tarr[0].p) && \\valid(tarr[0].q)",48); } __e_acsl_temporal_memcpy((void *)(larr),(void *)(& l),(size_t)32); __e_acsl_initialize((void *)(larr),sizeof(larger)); larr[0] = l; /*@ assert ¬\valid(larr[0].t.p) ∧ \valid(larr[0].t.q); */ { int __gen_e_acsl_initialized_14; int __gen_e_acsl_and_20; int __gen_e_acsl_and_22; __gen_e_acsl_initialized_14 = __e_acsl_initialized((void *)(& larr[0].t.p), sizeof(char *)); if (__gen_e_acsl_initialized_14) { int __gen_e_acsl_valid_14; __gen_e_acsl_valid_14 = __e_acsl_valid((void *)larr[0].t.p, sizeof(char), (void *)larr[0].t.p, (void *)(& larr[0].t.p)); __gen_e_acsl_and_20 = __gen_e_acsl_valid_14; } else __gen_e_acsl_and_20 = 0; if (! __gen_e_acsl_and_20) { int __gen_e_acsl_initialized_15; int __gen_e_acsl_and_21; __gen_e_acsl_initialized_15 = __e_acsl_initialized((void *)(& larr[0].t.q), sizeof(char *)); if (__gen_e_acsl_initialized_15) { int __gen_e_acsl_valid_15; __gen_e_acsl_valid_15 = __e_acsl_valid((void *)larr[0].t.q, sizeof(char), (void *)larr[0].t.q, (void *)(& larr[0].t.q)); __gen_e_acsl_and_21 = __gen_e_acsl_valid_15; } else __gen_e_acsl_and_21 = 0; __gen_e_acsl_and_22 = __gen_e_acsl_and_21; } else __gen_e_acsl_and_22 = 0; __e_acsl_assert(__gen_e_acsl_and_22,(char *)"Assertion",(char *)"main", (char *)"!\\valid(larr[0].t.p) && \\valid(larr[0].t.q)", 51); } __retres = 0; __e_acsl_delete_block((void *)(larr)); __e_acsl_delete_block((void *)(& lp)); __e_acsl_delete_block((void *)(& l)); __e_acsl_delete_block((void *)(tarr)); __e_acsl_delete_block((void *)(& t2)); __e_acsl_delete_block((void *)(& t1)); __e_acsl_delete_block((void *)(& a)); __e_acsl_memory_clean(); return __retres; }
int main(void) { int __retres; int x; __e_acsl_memory_init((int *)0,(char ***)0,(size_t)8); /*@ assert 0 ≡ 0; */ { __e_acsl_mpz_t __gen_e_acsl_; int __gen_e_acsl_eq; __gmpz_init_set_si(__gen_e_acsl_,0L); __gen_e_acsl_eq = __gmpz_cmp((__e_acsl_mpz_struct const *)(__gen_e_acsl_), (__e_acsl_mpz_struct const *)(__gen_e_acsl_)); __e_acsl_assert(__gen_e_acsl_eq == 0,(char *)"Assertion",(char *)"main", (char *)"0 == 0",6); __gmpz_clear(__gen_e_acsl_); } x = 0; x ++; /*@ assert 0 ≢ 1; */ { __e_acsl_mpz_t __gen_e_acsl__2; __e_acsl_mpz_t __gen_e_acsl__3; int __gen_e_acsl_ne; __gmpz_init_set_si(__gen_e_acsl__2,0L); __gmpz_init_set_si(__gen_e_acsl__3,1L); __gen_e_acsl_ne = __gmpz_cmp((__e_acsl_mpz_struct const *)(__gen_e_acsl__2), (__e_acsl_mpz_struct const *)(__gen_e_acsl__3)); __e_acsl_assert(__gen_e_acsl_ne != 0,(char *)"Assertion",(char *)"main", (char *)"0 != 1",8); __gmpz_clear(__gen_e_acsl__2); __gmpz_clear(__gen_e_acsl__3); } /*@ assert 1152921504606846975 ≡ 0xfffffffffffffff; */ { __e_acsl_mpz_t __gen_e_acsl__4; int __gen_e_acsl_eq_2; __gmpz_init_set_ui(__gen_e_acsl__4,1152921504606846975UL); __gen_e_acsl_eq_2 = __gmpz_cmp((__e_acsl_mpz_struct const *)(__gen_e_acsl__4), (__e_acsl_mpz_struct const *)(__gen_e_acsl__4)); __e_acsl_assert(__gen_e_acsl_eq_2 == 0,(char *)"Assertion", (char *)"main", (char *)"1152921504606846975 == 0xfffffffffffffff",9); __gmpz_clear(__gen_e_acsl__4); } /*@ assert 0xffffffffffffffffffffffffffffffff ≡ 0xffffffffffffffffffffffffffffffff; */ { __e_acsl_mpz_t __gen_e_acsl__5; int __gen_e_acsl_eq_3; __gmpz_init_set_str(__gen_e_acsl__5, "340282366920938463463374607431768211455",10); __gen_e_acsl_eq_3 = __gmpz_cmp((__e_acsl_mpz_struct const *)(__gen_e_acsl__5), (__e_acsl_mpz_struct const *)(__gen_e_acsl__5)); __e_acsl_assert(__gen_e_acsl_eq_3 == 0,(char *)"Assertion", (char *)"main", (char *)"0xffffffffffffffffffffffffffffffff == 0xffffffffffffffffffffffffffffffff", 11); __gmpz_clear(__gen_e_acsl__5); } __retres = 0; return __retres; }
int main(int argc, char const **argv) { int __retres; __e_acsl_memory_init(& argc,(char ***)(& argv),(size_t)8); __e_acsl_globals_init(); char *strings[2][2] = {{(char *)__gen_e_acsl_literal_string, (char *)__gen_e_acsl_literal_string_2}, {(char *)__gen_e_acsl_literal_string_3, (char *)__gen_e_acsl_literal_string_4}}; __e_acsl_store_block((void *)(strings),(size_t)32); __e_acsl_full_init((void *)(& strings)); __e_acsl_temporal_store_nblock((void *)(& strings[1][1]), (void *)__gen_e_acsl_literal_string_4); __e_acsl_temporal_store_nblock((void *)(& strings[1][0]), (void *)__gen_e_acsl_literal_string_3); __e_acsl_temporal_store_nblock((void *)(& strings[0][1]), (void *)__gen_e_acsl_literal_string_2); __e_acsl_temporal_store_nblock((void *)(& strings[0][0]), (void *)__gen_e_acsl_literal_string); char **p = (char **)(strings); __e_acsl_store_block((void *)(& p),(size_t)8); __e_acsl_full_init((void *)(& p)); __e_acsl_temporal_store_nblock((void *)(& p),(void *)(strings)); /*@ assert \valid_read(p); */ { int __gen_e_acsl_initialized; int __gen_e_acsl_and; __gen_e_acsl_initialized = __e_acsl_initialized((void *)(& p), sizeof(char **)); if (__gen_e_acsl_initialized) { int __gen_e_acsl_valid_read; __gen_e_acsl_valid_read = __e_acsl_valid_read((void *)p,sizeof(char *), (void *)p,(void *)(& p)); __gen_e_acsl_and = __gen_e_acsl_valid_read; } else __gen_e_acsl_and = 0; __e_acsl_assert(__gen_e_acsl_and,(char *)"Assertion",(char *)"main", (char *)"\\valid_read(p)",41); } /*@ assert \valid_read(*p); */ { int __gen_e_acsl_initialized_2; int __gen_e_acsl_and_3; __gen_e_acsl_initialized_2 = __e_acsl_initialized((void *)p, sizeof(char *)); if (__gen_e_acsl_initialized_2) { int __gen_e_acsl_initialized_3; int __gen_e_acsl_and_2; int __gen_e_acsl_valid_read_3; __gen_e_acsl_initialized_3 = __e_acsl_initialized((void *)(& p), sizeof(char **)); if (__gen_e_acsl_initialized_3) { int __gen_e_acsl_valid_read_2; __gen_e_acsl_valid_read_2 = __e_acsl_valid_read((void *)p, sizeof(char *), (void *)p, (void *)(& p)); __gen_e_acsl_and_2 = __gen_e_acsl_valid_read_2; } else __gen_e_acsl_and_2 = 0; __e_acsl_assert(__gen_e_acsl_and_2,(char *)"RTE",(char *)"main", (char *)"mem_access: \\valid_read(p)",42); __gen_e_acsl_valid_read_3 = __e_acsl_valid_read((void *)*p, sizeof(char), (void *)*p,(void *)p); __gen_e_acsl_and_3 = __gen_e_acsl_valid_read_3; } else __gen_e_acsl_and_3 = 0; __e_acsl_assert(__gen_e_acsl_and_3,(char *)"Assertion",(char *)"main", (char *)"\\valid_read(*p)",42); } char *str[4] = {(char *)__gen_e_acsl_literal_string_5, (char *)__gen_e_acsl_literal_string_6, (char *)__gen_e_acsl_literal_string_7, (char *)0}; __e_acsl_store_block((void *)(str),(size_t)32); __e_acsl_full_init((void *)(& str)); __e_acsl_temporal_store_nblock((void *)(& str[3]),(void *)0); __e_acsl_temporal_store_nblock((void *)(& str[2]), (void *)__gen_e_acsl_literal_string_7); __e_acsl_temporal_store_nblock((void *)(& str[1]), (void *)__gen_e_acsl_literal_string_6); __e_acsl_temporal_store_nblock((void *)(str), (void *)__gen_e_acsl_literal_string_5); __e_acsl_temporal_store_nblock((void *)(& p),(void *)(& str)); __e_acsl_full_init((void *)(& p)); p = (char **)(& str); /*@ assert \valid_read(p); */ { int __gen_e_acsl_initialized_4; int __gen_e_acsl_and_4; __gen_e_acsl_initialized_4 = __e_acsl_initialized((void *)(& p), sizeof(char **)); if (__gen_e_acsl_initialized_4) { int __gen_e_acsl_valid_read_4; __gen_e_acsl_valid_read_4 = __e_acsl_valid_read((void *)p, sizeof(char *), (void *)p, (void *)(& p)); __gen_e_acsl_and_4 = __gen_e_acsl_valid_read_4; } else __gen_e_acsl_and_4 = 0; __e_acsl_assert(__gen_e_acsl_and_4,(char *)"Assertion",(char *)"main", (char *)"\\valid_read(p)",48); } /*@ assert \valid_read(*p); */ { int __gen_e_acsl_initialized_5; int __gen_e_acsl_and_6; __gen_e_acsl_initialized_5 = __e_acsl_initialized((void *)p, sizeof(char *)); if (__gen_e_acsl_initialized_5) { int __gen_e_acsl_initialized_6; int __gen_e_acsl_and_5; int __gen_e_acsl_valid_read_6; __gen_e_acsl_initialized_6 = __e_acsl_initialized((void *)(& p), sizeof(char **)); if (__gen_e_acsl_initialized_6) { int __gen_e_acsl_valid_read_5; __gen_e_acsl_valid_read_5 = __e_acsl_valid_read((void *)p, sizeof(char *), (void *)p, (void *)(& p)); __gen_e_acsl_and_5 = __gen_e_acsl_valid_read_5; } else __gen_e_acsl_and_5 = 0; __e_acsl_assert(__gen_e_acsl_and_5,(char *)"RTE",(char *)"main", (char *)"mem_access: \\valid_read(p)",49); __gen_e_acsl_valid_read_6 = __e_acsl_valid_read((void *)*p, sizeof(char), (void *)*p,(void *)p); __gen_e_acsl_and_6 = __gen_e_acsl_valid_read_6; } else __gen_e_acsl_and_6 = 0; __e_acsl_assert(__gen_e_acsl_and_6,(char *)"Assertion",(char *)"main", (char *)"\\valid_read(*p)",49); } char **P = (char **)(Strings); __e_acsl_store_block((void *)(& P),(size_t)8); __e_acsl_full_init((void *)(& P)); __e_acsl_temporal_store_nblock((void *)(& P),(void *)(Strings)); /*@ assert \valid_read(P); */ { int __gen_e_acsl_initialized_7; int __gen_e_acsl_and_7; __gen_e_acsl_initialized_7 = __e_acsl_initialized((void *)(& P), sizeof(char **)); if (__gen_e_acsl_initialized_7) { int __gen_e_acsl_valid_read_7; __gen_e_acsl_valid_read_7 = __e_acsl_valid_read((void *)P, sizeof(char *), (void *)P, (void *)(& P)); __gen_e_acsl_and_7 = __gen_e_acsl_valid_read_7; } else __gen_e_acsl_and_7 = 0; __e_acsl_assert(__gen_e_acsl_and_7,(char *)"Assertion",(char *)"main", (char *)"\\valid_read(P)",53); } /*@ assert \valid_read(*P); */ { int __gen_e_acsl_initialized_8; int __gen_e_acsl_and_9; __gen_e_acsl_initialized_8 = __e_acsl_initialized((void *)P, sizeof(char *)); if (__gen_e_acsl_initialized_8) { int __gen_e_acsl_initialized_9; int __gen_e_acsl_and_8; int __gen_e_acsl_valid_read_9; __gen_e_acsl_initialized_9 = __e_acsl_initialized((void *)(& P), sizeof(char **)); if (__gen_e_acsl_initialized_9) { int __gen_e_acsl_valid_read_8; __gen_e_acsl_valid_read_8 = __e_acsl_valid_read((void *)P, sizeof(char *), (void *)P, (void *)(& P)); __gen_e_acsl_and_8 = __gen_e_acsl_valid_read_8; } else __gen_e_acsl_and_8 = 0; __e_acsl_assert(__gen_e_acsl_and_8,(char *)"RTE",(char *)"main", (char *)"mem_access: \\valid_read(P)",54); __gen_e_acsl_valid_read_9 = __e_acsl_valid_read((void *)*P, sizeof(char), (void *)*P,(void *)P); __gen_e_acsl_and_9 = __gen_e_acsl_valid_read_9; } else __gen_e_acsl_and_9 = 0; __e_acsl_assert(__gen_e_acsl_and_9,(char *)"Assertion",(char *)"main", (char *)"\\valid_read(*P)",54); } __e_acsl_temporal_store_nblock((void *)(& P),(void *)(& Str)); __e_acsl_full_init((void *)(& P)); P = (char **)(& Str); /*@ assert \valid_read(P); */ { int __gen_e_acsl_initialized_10; int __gen_e_acsl_and_10; __gen_e_acsl_initialized_10 = __e_acsl_initialized((void *)(& P), sizeof(char **)); if (__gen_e_acsl_initialized_10) { int __gen_e_acsl_valid_read_10; __gen_e_acsl_valid_read_10 = __e_acsl_valid_read((void *)P, sizeof(char *), (void *)P, (void *)(& P)); __gen_e_acsl_and_10 = __gen_e_acsl_valid_read_10; } else __gen_e_acsl_and_10 = 0; __e_acsl_assert(__gen_e_acsl_and_10,(char *)"Assertion",(char *)"main", (char *)"\\valid_read(P)",58); } /*@ assert \valid_read(*P); */ { int __gen_e_acsl_initialized_11; int __gen_e_acsl_and_12; __gen_e_acsl_initialized_11 = __e_acsl_initialized((void *)P, sizeof(char *)); if (__gen_e_acsl_initialized_11) { int __gen_e_acsl_initialized_12; int __gen_e_acsl_and_11; int __gen_e_acsl_valid_read_12; __gen_e_acsl_initialized_12 = __e_acsl_initialized((void *)(& P), sizeof(char **)); if (__gen_e_acsl_initialized_12) { int __gen_e_acsl_valid_read_11; __gen_e_acsl_valid_read_11 = __e_acsl_valid_read((void *)P, sizeof(char *), (void *)P, (void *)(& P)); __gen_e_acsl_and_11 = __gen_e_acsl_valid_read_11; } else __gen_e_acsl_and_11 = 0; __e_acsl_assert(__gen_e_acsl_and_11,(char *)"RTE",(char *)"main", (char *)"mem_access: \\valid_read(P)",59); __gen_e_acsl_valid_read_12 = __e_acsl_valid_read((void *)*P, sizeof(char), (void *)*P,(void *)P); __gen_e_acsl_and_12 = __gen_e_acsl_valid_read_12; } else __gen_e_acsl_and_12 = 0; __e_acsl_assert(__gen_e_acsl_and_12,(char *)"Assertion",(char *)"main", (char *)"\\valid_read(*P)",59); } int extra_lbits[1] = {0}; __e_acsl_store_block((void *)(extra_lbits),(size_t)4); __e_acsl_full_init((void *)(& extra_lbits)); tree_desc l_desc = {.extra_bits = extra_lbits}; __e_acsl_store_block((void *)(& l_desc),(size_t)8); __e_acsl_full_init((void *)(& l_desc)); __e_acsl_temporal_store_nblock((void *)(& l_desc.extra_bits), (void *)(extra_lbits)); tree_desc descs[2] = {{.extra_bits = extra_lbits}, {.extra_bits = extra_lbits}};
int goto_valid(void) { int __retres; int *p; int *q; int *r; __e_acsl_store_block((void *)(& r),(size_t)8); __e_acsl_store_block((void *)(& q),(size_t)8); __e_acsl_store_block((void *)(& p),(size_t)8); int a = 9; { int a1 = 0; __e_acsl_store_block((void *)(& a1),(size_t)4); __e_acsl_full_init((void *)(& a1)); __e_acsl_full_init((void *)(& p)); p = & a1; { int a2 = 0; __e_acsl_store_block((void *)(& a2),(size_t)4); __e_acsl_full_init((void *)(& a2)); __e_acsl_full_init((void *)(& q)); q = & a2; { int a3 = 0; __e_acsl_store_block((void *)(& a3),(size_t)4); __e_acsl_full_init((void *)(& a3)); __e_acsl_full_init((void *)(& r)); r = & a3; __e_acsl_delete_block((void *)(& a2)); __e_acsl_delete_block((void *)(& a3)); goto FIRST; __e_acsl_full_init((void *)(& p)); p = (int *)0; __e_acsl_full_init((void *)(& q)); q = & a; __e_acsl_full_init((void *)(& r)); r = q; __e_acsl_delete_block((void *)(& a3)); __e_acsl_delete_block((void *)(& a2)); } } FIRST: /*@ assert \valid(p); */ { int __gen_e_acsl_initialized; int __gen_e_acsl_and; __gen_e_acsl_initialized = __e_acsl_initialized((void *)(& p), sizeof(int *)); if (__gen_e_acsl_initialized) { int __gen_e_acsl_valid; __gen_e_acsl_valid = __e_acsl_valid((void *)p,sizeof(int),(void *)p, (void *)(& p)); __gen_e_acsl_and = __gen_e_acsl_valid; } else __gen_e_acsl_and = 0; __e_acsl_assert(__gen_e_acsl_and,(char *)"Assertion", (char *)"goto_valid",(char *)"\\valid(p)",46); } /*@ assert ¬\valid(q); */ { int __gen_e_acsl_initialized_2; int __gen_e_acsl_and_2; __gen_e_acsl_initialized_2 = __e_acsl_initialized((void *)(& q), sizeof(int *)); if (__gen_e_acsl_initialized_2) { int __gen_e_acsl_valid_2; __gen_e_acsl_valid_2 = __e_acsl_valid((void *)q,sizeof(int), (void *)q,(void *)(& q)); __gen_e_acsl_and_2 = __gen_e_acsl_valid_2; } else __gen_e_acsl_and_2 = 0; __e_acsl_assert(! __gen_e_acsl_and_2,(char *)"Assertion", (char *)"goto_valid",(char *)"!\\valid(q)",47); } /*@ assert ¬\valid(r); */ { int __gen_e_acsl_initialized_3; int __gen_e_acsl_and_3; __gen_e_acsl_initialized_3 = __e_acsl_initialized((void *)(& r), sizeof(int *)); if (__gen_e_acsl_initialized_3) { int __gen_e_acsl_valid_3; __gen_e_acsl_valid_3 = __e_acsl_valid((void *)r,sizeof(int), (void *)r,(void *)(& r)); __gen_e_acsl_and_3 = __gen_e_acsl_valid_3; } else __gen_e_acsl_and_3 = 0; __e_acsl_assert(! __gen_e_acsl_and_3,(char *)"Assertion", (char *)"goto_valid",(char *)"!\\valid(r)",48); } __e_acsl_delete_block((void *)(& a1)); goto SECOND; __e_acsl_full_init((void *)(& q)); q = & a; __e_acsl_full_init((void *)(& r)); r = q; __e_acsl_full_init((void *)(& p)); p = r; __e_acsl_delete_block((void *)(& a1)); } SECOND: /*@ assert ¬\valid(p); */ { int __gen_e_acsl_initialized_4; int __gen_e_acsl_and_4; __gen_e_acsl_initialized_4 = __e_acsl_initialized((void *)(& p), sizeof(int *)); if (__gen_e_acsl_initialized_4) { int __gen_e_acsl_valid_4; __gen_e_acsl_valid_4 = __e_acsl_valid((void *)p,sizeof(int),(void *)p, (void *)(& p)); __gen_e_acsl_and_4 = __gen_e_acsl_valid_4; } else __gen_e_acsl_and_4 = 0; __e_acsl_assert(! __gen_e_acsl_and_4,(char *)"Assertion", (char *)"goto_valid",(char *)"!\\valid(p)",56); } /*@ assert ¬\valid(q); */ { int __gen_e_acsl_initialized_5; int __gen_e_acsl_and_5; __gen_e_acsl_initialized_5 = __e_acsl_initialized((void *)(& q), sizeof(int *)); if (__gen_e_acsl_initialized_5) { int __gen_e_acsl_valid_5; __gen_e_acsl_valid_5 = __e_acsl_valid((void *)q,sizeof(int),(void *)q, (void *)(& q)); __gen_e_acsl_and_5 = __gen_e_acsl_valid_5; } else __gen_e_acsl_and_5 = 0; __e_acsl_assert(! __gen_e_acsl_and_5,(char *)"Assertion", (char *)"goto_valid",(char *)"!\\valid(q)",57); } /*@ assert ¬\valid(r); */ { int __gen_e_acsl_initialized_6; int __gen_e_acsl_and_6; __gen_e_acsl_initialized_6 = __e_acsl_initialized((void *)(& r), sizeof(int *)); if (__gen_e_acsl_initialized_6) { int __gen_e_acsl_valid_6; __gen_e_acsl_valid_6 = __e_acsl_valid((void *)r,sizeof(int),(void *)r, (void *)(& r)); __gen_e_acsl_and_6 = __gen_e_acsl_valid_6; } else __gen_e_acsl_and_6 = 0; __e_acsl_assert(! __gen_e_acsl_and_6,(char *)"Assertion", (char *)"goto_valid",(char *)"!\\valid(r)",58); } __retres = 0; __e_acsl_delete_block((void *)(& r)); __e_acsl_delete_block((void *)(& q)); __e_acsl_delete_block((void *)(& p)); return __retres; }
int __gen_e_acsl_main(int argc, char **argv) { int __retres; int i; /*@ assert ∀ int k; 0 ≤ k < argc ⇒ \valid(argv + k); */ { int __gen_e_acsl_forall; int __gen_e_acsl_k; __e_acsl_store_block((void *)(& argv),(size_t)8); __gen_e_acsl_forall = 1; __gen_e_acsl_k = 0; while (1) { if (__gen_e_acsl_k < argc) ; else break; { int __gen_e_acsl_valid; __gen_e_acsl_valid = __e_acsl_valid((void *)(argv + __gen_e_acsl_k), sizeof(char *),(void *)argv, (void *)(& argv)); if (__gen_e_acsl_valid) ; else { __gen_e_acsl_forall = 0; goto e_acsl_end_loop1; } } __gen_e_acsl_k ++; } e_acsl_end_loop1: ; __e_acsl_assert(__gen_e_acsl_forall,(char *)"Assertion",(char *)"main", (char *)"\\forall int k; 0 <= k < argc ==> \\valid(argv + k)", 12); } /*@ assert \block_length(argv) ≡ (argc + 1) * sizeof(char *); */ { unsigned long __gen_e_acsl_block_length; __e_acsl_mpz_t __gen_e_acsl_block_length_2; __e_acsl_mpz_t __gen_e_acsl_; int __gen_e_acsl_eq; __gen_e_acsl_block_length = __e_acsl_block_length((void *)argv); __gmpz_init_set_ui(__gen_e_acsl_block_length_2,__gen_e_acsl_block_length); __gmpz_init_set_si(__gen_e_acsl_,(argc + 1L) * 8); __gen_e_acsl_eq = __gmpz_cmp((__e_acsl_mpz_struct const *)(__gen_e_acsl_block_length_2), (__e_acsl_mpz_struct const *)(__gen_e_acsl_)); __e_acsl_assert(__gen_e_acsl_eq == 0,(char *)"Assertion",(char *)"main", (char *)"\\block_length(argv) == (argc + 1) * sizeof(char *)", 13); __gmpz_clear(__gen_e_acsl_block_length_2); __gmpz_clear(__gen_e_acsl_); } /*@ assert *(argv + argc) ≡ \null; */ { int __gen_e_acsl_valid_read; __gen_e_acsl_valid_read = __e_acsl_valid_read((void *)(argv + argc), sizeof(char *), (void *)argv, (void *)(& argv)); __e_acsl_assert(__gen_e_acsl_valid_read,(char *)"RTE",(char *)"main", (char *)"mem_access: \\valid_read(argv + argc)",15); /*@ assert Eva: mem_access: \valid_read(argv + argc); */ __e_acsl_assert(*(argv + argc) == (char *)0,(char *)"Assertion", (char *)"main",(char *)"*(argv + argc) == \\null",15); } /*@ assert ¬\valid(*(argv + argc)); */ { int __gen_e_acsl_initialized; int __gen_e_acsl_and; __gen_e_acsl_initialized = __e_acsl_initialized((void *)(argv + argc), sizeof(char *)); if (__gen_e_acsl_initialized) { int __gen_e_acsl_valid_read_2; int __gen_e_acsl_valid_2; __gen_e_acsl_valid_read_2 = __e_acsl_valid_read((void *)(argv + argc), sizeof(char *), (void *)argv, (void *)(& argv)); __e_acsl_assert(__gen_e_acsl_valid_read_2,(char *)"RTE",(char *)"main", (char *)"mem_access: \\valid_read(argv + argc)",16); /*@ assert Eva: mem_access: \valid_read(argv + argc); */ __gen_e_acsl_valid_2 = __e_acsl_valid((void *)*(argv + argc), sizeof(char), (void *)*(argv + argc), (void *)(argv + argc)); __gen_e_acsl_and = __gen_e_acsl_valid_2; } else __gen_e_acsl_and = 0; __e_acsl_assert(! __gen_e_acsl_and,(char *)"Assertion",(char *)"main", (char *)"!\\valid(*(argv + argc))",16); } i = 0; while (i < argc) { { size_t tmp; tmp = __gen_e_acsl_strlen((char const *)*(argv + i)); int len = (int)tmp; /*@ assert \valid(*(argv + i)); */ { int __gen_e_acsl_initialized_2; int __gen_e_acsl_and_2; __gen_e_acsl_initialized_2 = __e_acsl_initialized((void *)(argv + i), sizeof(char *)); if (__gen_e_acsl_initialized_2) { int __gen_e_acsl_valid_read_3; int __gen_e_acsl_valid_3; __gen_e_acsl_valid_read_3 = __e_acsl_valid_read((void *)(argv + i), sizeof(char *), (void *)argv, (void *)(& argv)); __e_acsl_assert(__gen_e_acsl_valid_read_3,(char *)"RTE", (char *)"main", (char *)"mem_access: \\valid_read(argv + i)",19); __gen_e_acsl_valid_3 = __e_acsl_valid((void *)*(argv + i), sizeof(char), (void *)*(argv + i), (void *)(argv + i)); __gen_e_acsl_and_2 = __gen_e_acsl_valid_3; } else __gen_e_acsl_and_2 = 0; __e_acsl_assert(__gen_e_acsl_and_2,(char *)"Assertion", (char *)"main",(char *)"\\valid(*(argv + i))",19); } /*@ assert ∀ int k; 0 ≤ k ≤ len ⇒ \valid(*(argv + i) + k); */ { int __gen_e_acsl_forall_2; long __gen_e_acsl_k_2; __gen_e_acsl_forall_2 = 1; __gen_e_acsl_k_2 = 0; while (1) { if (__gen_e_acsl_k_2 <= (long)len) ; else break; { int __gen_e_acsl_valid_read_4; int __gen_e_acsl_valid_4; __gen_e_acsl_valid_read_4 = __e_acsl_valid_read((void *)( argv + i), sizeof(char *), (void *)argv, (void *)(& argv)); __e_acsl_assert(__gen_e_acsl_valid_read_4,(char *)"RTE", (char *)"main", (char *)"mem_access: \\valid_read(argv + i)",20); __gen_e_acsl_valid_4 = __e_acsl_valid((void *)(*(argv + i) + __gen_e_acsl_k_2), sizeof(char), (void *)*(argv + i), (void *)(argv + i)); if (__gen_e_acsl_valid_4) ; else { __gen_e_acsl_forall_2 = 0; goto e_acsl_end_loop2; } } __gen_e_acsl_k_2 ++; } e_acsl_end_loop2: ; __e_acsl_assert(__gen_e_acsl_forall_2,(char *)"Assertion", (char *)"main", (char *)"\\forall int k; 0 <= k <= len ==> \\valid(*(argv + i) + k)", 20); } } i ++; } __retres = 0; __e_acsl_delete_block((void *)(& argv)); return __retres; }
int main(void) { int __retres; struct Zero zero; __e_acsl_memory_init((int *)0,(char ***)0,(size_t)8); __e_acsl_globals_init(); __e_acsl_store_block((void *)(& zero),(size_t)0); /*@ assert \block_length(&ZERO) ≡ 0; */ { unsigned long __gen_e_acsl_block_length; __gen_e_acsl_block_length = __e_acsl_block_length((void *)(& ZERO)); __e_acsl_assert(__gen_e_acsl_block_length == 0UL,(char *)"Assertion", (char *)"main",(char *)"\\block_length(&ZERO) == 0",15); } /*@ assert \block_length(&zero) ≡ 0; */ { unsigned long __gen_e_acsl_block_length_2; __gen_e_acsl_block_length_2 = __e_acsl_block_length((void *)(& zero)); __e_acsl_assert(__gen_e_acsl_block_length_2 == 0UL,(char *)"Assertion", (char *)"main",(char *)"\\block_length(&zero) == 0",16); } PA = (int *)(& A); /*@ assert \block_length((int *)A) ≡ sizeof(A); */ { unsigned long __gen_e_acsl_block_length_3; __gen_e_acsl_block_length_3 = __e_acsl_block_length((void *)(A)); __e_acsl_assert(__gen_e_acsl_block_length_3 == 16UL,(char *)"Assertion", (char *)"main", (char *)"\\block_length((int *)A) == sizeof(A)",20); } /*@ assert \block_length(&A[3]) ≡ sizeof(A); */ { unsigned long __gen_e_acsl_block_length_4; __gen_e_acsl_block_length_4 = __e_acsl_block_length((void *)(& A[3])); __e_acsl_assert(__gen_e_acsl_block_length_4 == 16UL,(char *)"Assertion", (char *)"main", (char *)"\\block_length(&A[3]) == sizeof(A)",21); } /*@ assert \block_length(PA) ≡ sizeof(A); */ { unsigned long __gen_e_acsl_block_length_5; __gen_e_acsl_block_length_5 = __e_acsl_block_length((void *)PA); __e_acsl_assert(__gen_e_acsl_block_length_5 == 16UL,(char *)"Assertion", (char *)"main",(char *)"\\block_length(PA) == sizeof(A)", 22); } PA ++; /*@ assert \block_length(PA + 1) ≡ \block_length(&A[1]); */ { unsigned long __gen_e_acsl_block_length_6; unsigned long __gen_e_acsl_block_length_7; __gen_e_acsl_block_length_6 = __e_acsl_block_length((void *)(PA + 1)); __gen_e_acsl_block_length_7 = __e_acsl_block_length((void *)(& A[1])); __e_acsl_assert(__gen_e_acsl_block_length_6 == __gen_e_acsl_block_length_7, (char *)"Assertion",(char *)"main", (char *)"\\block_length(PA + 1) == \\block_length(&A[1])", 24); } int a[4] = {1, 2, 3, 4}; __e_acsl_store_block((void *)(a),(size_t)16); __e_acsl_full_init((void *)(& a)); int *pa = (int *)(& a); __e_acsl_store_block((void *)(& pa),(size_t)8); __e_acsl_full_init((void *)(& pa)); /*@ assert \block_length((int *)a) ≡ sizeof(a); */ { unsigned long __gen_e_acsl_block_length_8; __gen_e_acsl_block_length_8 = __e_acsl_block_length((void *)(a)); __e_acsl_assert(__gen_e_acsl_block_length_8 == 16UL,(char *)"Assertion", (char *)"main", (char *)"\\block_length((int *)a) == sizeof(a)",29); } /*@ assert \block_length(&a[3]) ≡ sizeof(a); */ { unsigned long __gen_e_acsl_block_length_9; __gen_e_acsl_block_length_9 = __e_acsl_block_length((void *)(& a[3])); __e_acsl_assert(__gen_e_acsl_block_length_9 == 16UL,(char *)"Assertion", (char *)"main", (char *)"\\block_length(&a[3]) == sizeof(a)",30); } /*@ assert \block_length(pa) ≡ sizeof(a); */ { unsigned long __gen_e_acsl_block_length_10; __gen_e_acsl_block_length_10 = __e_acsl_block_length((void *)pa); __e_acsl_assert(__gen_e_acsl_block_length_10 == 16UL,(char *)"Assertion", (char *)"main",(char *)"\\block_length(pa) == sizeof(a)", 31); } __e_acsl_full_init((void *)(& pa)); pa ++; /*@ assert \block_length(pa + 1) ≡ \block_length(&a[1]); */ { unsigned long __gen_e_acsl_block_length_11; unsigned long __gen_e_acsl_block_length_12; __gen_e_acsl_block_length_11 = __e_acsl_block_length((void *)(pa + 1)); __gen_e_acsl_block_length_12 = __e_acsl_block_length((void *)(& a[1])); __e_acsl_assert(__gen_e_acsl_block_length_11 == __gen_e_acsl_block_length_12, (char *)"Assertion",(char *)"main", (char *)"\\block_length(pa + 1) == \\block_length(&a[1])", 33); } long l = (long)4; __e_acsl_store_block((void *)(& l),(size_t)8); __e_acsl_full_init((void *)(& l)); char *pl = (char *)(& l); __e_acsl_store_block((void *)(& pl),(size_t)8); __e_acsl_full_init((void *)(& pl)); /*@ assert \block_length(&l) ≡ sizeof(long); */ { unsigned long __gen_e_acsl_block_length_13; __gen_e_acsl_block_length_13 = __e_acsl_block_length((void *)(& l)); __e_acsl_assert(__gen_e_acsl_block_length_13 == 8UL,(char *)"Assertion", (char *)"main", (char *)"\\block_length(&l) == sizeof(long)",39); } /*@ assert \block_length(pl) ≡ sizeof(long); */ { unsigned long __gen_e_acsl_block_length_14; __gen_e_acsl_block_length_14 = __e_acsl_block_length((void *)pl); __e_acsl_assert(__gen_e_acsl_block_length_14 == 8UL,(char *)"Assertion", (char *)"main", (char *)"\\block_length(pl) == sizeof(long)",40); } /*@ assert \block_length(pl + 7) ≡ sizeof(long); */ { unsigned long __gen_e_acsl_block_length_15; __gen_e_acsl_block_length_15 = __e_acsl_block_length((void *)(pl + 7)); __e_acsl_assert(__gen_e_acsl_block_length_15 == 8UL,(char *)"Assertion", (char *)"main", (char *)"\\block_length(pl + 7) == sizeof(long)",41); } int *pi = (int *)(& l); __e_acsl_store_block((void *)(& pi),(size_t)8); __e_acsl_full_init((void *)(& pi)); /*@ assert \block_length(pi) ≡ \block_length(&l); */ { unsigned long __gen_e_acsl_block_length_16; unsigned long __gen_e_acsl_block_length_17; __gen_e_acsl_block_length_16 = __e_acsl_block_length((void *)pi); __gen_e_acsl_block_length_17 = __e_acsl_block_length((void *)(& l)); __e_acsl_assert(__gen_e_acsl_block_length_16 == __gen_e_acsl_block_length_17, (char *)"Assertion",(char *)"main", (char *)"\\block_length(pi) == \\block_length(&l)",43); } __e_acsl_full_init((void *)(& pi)); pi ++; /*@ assert \block_length(pi) ≡ \block_length(&l); */ { unsigned long __gen_e_acsl_block_length_18; unsigned long __gen_e_acsl_block_length_19; __gen_e_acsl_block_length_18 = __e_acsl_block_length((void *)pi); __gen_e_acsl_block_length_19 = __e_acsl_block_length((void *)(& l)); __e_acsl_assert(__gen_e_acsl_block_length_18 == __gen_e_acsl_block_length_19, (char *)"Assertion",(char *)"main", (char *)"\\block_length(pi) == \\block_length(&l)",45); } size_t size = (unsigned long)12; char *p = malloc(size); __e_acsl_store_block((void *)(& p),(size_t)8); __e_acsl_full_init((void *)(& p)); /*@ assert \block_length(p) ≡ size; */ { unsigned long __gen_e_acsl_block_length_20; __gen_e_acsl_block_length_20 = __e_acsl_block_length((void *)p); __e_acsl_assert(__gen_e_acsl_block_length_20 == size,(char *)"Assertion", (char *)"main",(char *)"\\block_length(p) == size",50); } /*@ assert \block_length(p + 11) ≡ size; */ { unsigned long __gen_e_acsl_block_length_21; __gen_e_acsl_block_length_21 = __e_acsl_block_length((void *)(p + 11)); __e_acsl_assert(__gen_e_acsl_block_length_21 == size,(char *)"Assertion", (char *)"main",(char *)"\\block_length(p + 11) == size", 51); } __e_acsl_full_init((void *)(& p)); p += 5; /*@ assert \block_length(p + 5) ≡ \block_length(p - 5); */ { unsigned long __gen_e_acsl_block_length_22; unsigned long __gen_e_acsl_block_length_23; __gen_e_acsl_block_length_22 = __e_acsl_block_length((void *)(p + 5)); __gen_e_acsl_block_length_23 = __e_acsl_block_length((void *)(p - 5)); __e_acsl_assert(__gen_e_acsl_block_length_22 == __gen_e_acsl_block_length_23, (char *)"Assertion",(char *)"main", (char *)"\\block_length(p + 5) == \\block_length(p - 5)", 53); } size = (unsigned long)30 * sizeof(long); long *q = malloc(size); __e_acsl_store_block((void *)(& q),(size_t)8); __e_acsl_full_init((void *)(& q)); /*@ assert \block_length(q) ≡ size; */ { unsigned long __gen_e_acsl_block_length_24; __gen_e_acsl_block_length_24 = __e_acsl_block_length((void *)q); __e_acsl_assert(__gen_e_acsl_block_length_24 == size,(char *)"Assertion", (char *)"main",(char *)"\\block_length(q) == size",59); } __e_acsl_full_init((void *)(& q)); q += 4; /*@ assert \block_length(q) ≡ size; */ { unsigned long __gen_e_acsl_block_length_25; __gen_e_acsl_block_length_25 = __e_acsl_block_length((void *)q); __e_acsl_assert(__gen_e_acsl_block_length_25 == size,(char *)"Assertion", (char *)"main",(char *)"\\block_length(q) == size",61); } __retres = 0; __e_acsl_delete_block((void *)(& ZERO)); __e_acsl_delete_block((void *)(& PA)); __e_acsl_delete_block((void *)(A)); __e_acsl_delete_block((void *)(& q)); __e_acsl_delete_block((void *)(& p)); __e_acsl_delete_block((void *)(& pi)); __e_acsl_delete_block((void *)(& pl)); __e_acsl_delete_block((void *)(& l)); __e_acsl_delete_block((void *)(& pa)); __e_acsl_delete_block((void *)(a)); __e_acsl_delete_block((void *)(& zero)); __e_acsl_memory_clean(); return __retres; }
int switch_valid(void) { int __retres; int *p; int *q; int *s; __e_acsl_store_block((void *)(& s),(size_t)8); __e_acsl_store_block((void *)(& q),(size_t)8); __e_acsl_store_block((void *)(& p),(size_t)8); int i = 1; __e_acsl_store_block((void *)(& i),(size_t)4); __e_acsl_full_init((void *)(& i)); __e_acsl_full_init((void *)(& s)); s = & i; switch (i) { default: { int a1 = 0; __e_acsl_store_block((void *)(& a1),(size_t)4); __e_acsl_full_init((void *)(& a1)); __e_acsl_full_init((void *)(& p)); p = & a1; { int a2 = 0; __e_acsl_store_block((void *)(& a2),(size_t)4); __e_acsl_full_init((void *)(& a2)); __e_acsl_full_init((void *)(& q)); q = & a2; /*@ assert \valid(p); */ { int __gen_e_acsl_initialized; int __gen_e_acsl_and; __gen_e_acsl_initialized = __e_acsl_initialized((void *)(& p), sizeof(int *)); if (__gen_e_acsl_initialized) { int __gen_e_acsl_valid; __gen_e_acsl_valid = __e_acsl_valid((void *)p,sizeof(int), (void *)p,(void *)(& p)); __gen_e_acsl_and = __gen_e_acsl_valid; } else __gen_e_acsl_and = 0; __e_acsl_assert(__gen_e_acsl_and,(char *)"Assertion", (char *)"switch_valid",(char *)"\\valid(p)",76); } /*@ assert \valid(q); */ { int __gen_e_acsl_initialized_2; int __gen_e_acsl_and_2; __gen_e_acsl_initialized_2 = __e_acsl_initialized((void *)(& q), sizeof(int *)); if (__gen_e_acsl_initialized_2) { int __gen_e_acsl_valid_2; __gen_e_acsl_valid_2 = __e_acsl_valid((void *)q,sizeof(int), (void *)q,(void *)(& q)); __gen_e_acsl_and_2 = __gen_e_acsl_valid_2; } else __gen_e_acsl_and_2 = 0; __e_acsl_assert(__gen_e_acsl_and_2,(char *)"Assertion", (char *)"switch_valid",(char *)"\\valid(q)",77); } /*@ assert \valid(s); */ { int __gen_e_acsl_initialized_3; int __gen_e_acsl_and_3; __gen_e_acsl_initialized_3 = __e_acsl_initialized((void *)(& s), sizeof(int *)); if (__gen_e_acsl_initialized_3) { int __gen_e_acsl_valid_3; __gen_e_acsl_valid_3 = __e_acsl_valid((void *)s,sizeof(int), (void *)s,(void *)(& s)); __gen_e_acsl_and_3 = __gen_e_acsl_valid_3; } else __gen_e_acsl_and_3 = 0; __e_acsl_assert(__gen_e_acsl_and_3,(char *)"Assertion", (char *)"switch_valid",(char *)"\\valid(s)",78); } __e_acsl_delete_block((void *)(& a1)); __e_acsl_delete_block((void *)(& a2)); break; __e_acsl_delete_block((void *)(& a2)); } __e_acsl_full_init((void *)(& q)); q = & i; __e_acsl_full_init((void *)(& p)); p = q; __e_acsl_full_init((void *)(& s)); s = (int *)0; __e_acsl_delete_block((void *)(& a1)); } } /*@ assert ¬\valid(q); */ { int __gen_e_acsl_initialized_4; int __gen_e_acsl_and_4; __gen_e_acsl_initialized_4 = __e_acsl_initialized((void *)(& q), sizeof(int *)); if (__gen_e_acsl_initialized_4) { int __gen_e_acsl_valid_4; __gen_e_acsl_valid_4 = __e_acsl_valid((void *)q,sizeof(int),(void *)q, (void *)(& q)); __gen_e_acsl_and_4 = __gen_e_acsl_valid_4; } else __gen_e_acsl_and_4 = 0; __e_acsl_assert(! __gen_e_acsl_and_4,(char *)"Assertion", (char *)"switch_valid",(char *)"!\\valid(q)",87); } /*@ assert ¬\valid(p); */ { int __gen_e_acsl_initialized_5; int __gen_e_acsl_and_5; __gen_e_acsl_initialized_5 = __e_acsl_initialized((void *)(& p), sizeof(int *)); if (__gen_e_acsl_initialized_5) { int __gen_e_acsl_valid_5; __gen_e_acsl_valid_5 = __e_acsl_valid((void *)p,sizeof(int),(void *)p, (void *)(& p)); __gen_e_acsl_and_5 = __gen_e_acsl_valid_5; } else __gen_e_acsl_and_5 = 0; __e_acsl_assert(! __gen_e_acsl_and_5,(char *)"Assertion", (char *)"switch_valid",(char *)"!\\valid(p)",88); } /*@ assert \valid(s); */ { int __gen_e_acsl_initialized_6; int __gen_e_acsl_and_6; __gen_e_acsl_initialized_6 = __e_acsl_initialized((void *)(& s), sizeof(int *)); if (__gen_e_acsl_initialized_6) { int __gen_e_acsl_valid_6; __gen_e_acsl_valid_6 = __e_acsl_valid((void *)s,sizeof(int),(void *)s, (void *)(& s)); __gen_e_acsl_and_6 = __gen_e_acsl_valid_6; } else __gen_e_acsl_and_6 = 0; __e_acsl_assert(__gen_e_acsl_and_6,(char *)"Assertion", (char *)"switch_valid",(char *)"\\valid(s)",89); } __retres = 0; __e_acsl_delete_block((void *)(& s)); __e_acsl_delete_block((void *)(& q)); __e_acsl_delete_block((void *)(& p)); __e_acsl_delete_block((void *)(& i)); return __retres; }
int main(void) { int __retres; __e_acsl_memory_init((int *)0,(char ***)0,(size_t)8); __e_acsl_globals_init(); PA = (int *)(& A); /*@ assert \offset((int *)A) ≡ 0; */ { unsigned long __gen_e_acsl_offset; __gen_e_acsl_offset = __e_acsl_offset((void *)(A)); __e_acsl_assert(__gen_e_acsl_offset == 0UL,(char *)"Assertion", (char *)"main",(char *)"\\offset((int *)A) == 0",13); } /*@ assert \offset(&A[3]) ≡ 12; */ { unsigned long __gen_e_acsl_offset_2; __gen_e_acsl_offset_2 = __e_acsl_offset((void *)(& A[3])); __e_acsl_assert(__gen_e_acsl_offset_2 == 12UL,(char *)"Assertion", (char *)"main",(char *)"\\offset(&A[3]) == 12",14); } /*@ assert \offset(PA) ≡ 0; */ { unsigned long __gen_e_acsl_offset_3; __gen_e_acsl_offset_3 = __e_acsl_offset((void *)PA); __e_acsl_assert(__gen_e_acsl_offset_3 == 0UL,(char *)"Assertion", (char *)"main",(char *)"\\offset(PA) == 0",15); } PA ++; /*@ assert \offset(PA + 1) ≡ 8; */ { unsigned long __gen_e_acsl_offset_4; __gen_e_acsl_offset_4 = __e_acsl_offset((void *)(PA + 1)); __e_acsl_assert(__gen_e_acsl_offset_4 == 8UL,(char *)"Assertion", (char *)"main",(char *)"\\offset(PA + 1) == 8",17); } int a[4] = {1, 2, 3, 4}; __e_acsl_store_block((void *)(a),(size_t)16); __e_acsl_full_init((void *)(& a)); /*@ assert \offset((int *)a) ≡ 0; */ { unsigned long __gen_e_acsl_offset_5; __gen_e_acsl_offset_5 = __e_acsl_offset((void *)(a)); __e_acsl_assert(__gen_e_acsl_offset_5 == 0UL,(char *)"Assertion", (char *)"main",(char *)"\\offset((int *)a) == 0",21); } /*@ assert \offset(&a[1]) ≡ 4; */ { unsigned long __gen_e_acsl_offset_6; __gen_e_acsl_offset_6 = __e_acsl_offset((void *)(& a[1])); __e_acsl_assert(__gen_e_acsl_offset_6 == 4UL,(char *)"Assertion", (char *)"main",(char *)"\\offset(&a[1]) == 4",22); } /*@ assert \offset(&a[3]) ≡ 12; */ { unsigned long __gen_e_acsl_offset_7; __gen_e_acsl_offset_7 = __e_acsl_offset((void *)(& a[3])); __e_acsl_assert(__gen_e_acsl_offset_7 == 12UL,(char *)"Assertion", (char *)"main",(char *)"\\offset(&a[3]) == 12",23); } long l = (long)4; __e_acsl_store_block((void *)(& l),(size_t)8); __e_acsl_full_init((void *)(& l)); char *pl = (char *)(& l); __e_acsl_store_block((void *)(& pl),(size_t)8); __e_acsl_full_init((void *)(& pl)); /*@ assert \offset(&l) ≡ 0; */ { unsigned long __gen_e_acsl_offset_8; __gen_e_acsl_offset_8 = __e_acsl_offset((void *)(& l)); __e_acsl_assert(__gen_e_acsl_offset_8 == 0UL,(char *)"Assertion", (char *)"main",(char *)"\\offset(&l) == 0",28); } /*@ assert \offset(pl) ≡ 0; */ { unsigned long __gen_e_acsl_offset_9; __gen_e_acsl_offset_9 = __e_acsl_offset((void *)pl); __e_acsl_assert(__gen_e_acsl_offset_9 == 0UL,(char *)"Assertion", (char *)"main",(char *)"\\offset(pl) == 0",29); } /*@ assert \offset(pl + 1) ≡ 1; */ { unsigned long __gen_e_acsl_offset_10; __gen_e_acsl_offset_10 = __e_acsl_offset((void *)(pl + 1)); __e_acsl_assert(__gen_e_acsl_offset_10 == 1UL,(char *)"Assertion", (char *)"main",(char *)"\\offset(pl + 1) == 1",30); } /*@ assert \offset(pl + 7) ≡ 7; */ { unsigned long __gen_e_acsl_offset_11; __gen_e_acsl_offset_11 = __e_acsl_offset((void *)(pl + 7)); __e_acsl_assert(__gen_e_acsl_offset_11 == 7UL,(char *)"Assertion", (char *)"main",(char *)"\\offset(pl + 7) == 7",31); } int *pi = (int *)(& l); __e_acsl_store_block((void *)(& pi),(size_t)8); __e_acsl_full_init((void *)(& pi)); /*@ assert \offset(pi) ≡ 0; */ { unsigned long __gen_e_acsl_offset_12; __gen_e_acsl_offset_12 = __e_acsl_offset((void *)pi); __e_acsl_assert(__gen_e_acsl_offset_12 == 0UL,(char *)"Assertion", (char *)"main",(char *)"\\offset(pi) == 0",33); } __e_acsl_full_init((void *)(& pi)); pi ++; /*@ assert \offset(pi) ≡ 4; */ { unsigned long __gen_e_acsl_offset_13; __gen_e_acsl_offset_13 = __e_acsl_offset((void *)pi); __e_acsl_assert(__gen_e_acsl_offset_13 == 4UL,(char *)"Assertion", (char *)"main",(char *)"\\offset(pi) == 4",35); } char *p = malloc((unsigned long)12); __e_acsl_store_block((void *)(& p),(size_t)8); __e_acsl_full_init((void *)(& p)); /*@ assert \offset(p) ≡ 0; */ { unsigned long __gen_e_acsl_offset_14; __gen_e_acsl_offset_14 = __e_acsl_offset((void *)p); __e_acsl_assert(__gen_e_acsl_offset_14 == 0UL,(char *)"Assertion", (char *)"main",(char *)"\\offset(p) == 0",39); } /*@ assert \offset(p + 1) ≡ 1; */ { unsigned long __gen_e_acsl_offset_15; __gen_e_acsl_offset_15 = __e_acsl_offset((void *)(p + 1)); __e_acsl_assert(__gen_e_acsl_offset_15 == 1UL,(char *)"Assertion", (char *)"main",(char *)"\\offset(p + 1) == 1",40); } /*@ assert \offset(p + 11) ≡ 11; */ { unsigned long __gen_e_acsl_offset_16; __gen_e_acsl_offset_16 = __e_acsl_offset((void *)(p + 11)); __e_acsl_assert(__gen_e_acsl_offset_16 == 11UL,(char *)"Assertion", (char *)"main",(char *)"\\offset(p + 11) == 11",41); } __e_acsl_full_init((void *)(& p)); p += 5; /*@ assert \offset(p + 5) ≡ 10; */ { unsigned long __gen_e_acsl_offset_17; __gen_e_acsl_offset_17 = __e_acsl_offset((void *)(p + 5)); __e_acsl_assert(__gen_e_acsl_offset_17 == 10UL,(char *)"Assertion", (char *)"main",(char *)"\\offset(p + 5) == 10",43); } /*@ assert \offset(p - 5) ≡ 0; */ { unsigned long __gen_e_acsl_offset_18; __gen_e_acsl_offset_18 = __e_acsl_offset((void *)(p - 5)); __e_acsl_assert(__gen_e_acsl_offset_18 == 0UL,(char *)"Assertion", (char *)"main",(char *)"\\offset(p - 5) == 0",44); } long *q = malloc((unsigned long)30 * sizeof(long)); __e_acsl_store_block((void *)(& q),(size_t)8); __e_acsl_full_init((void *)(& q)); /*@ assert \offset(q) ≡ 0; */ { unsigned long __gen_e_acsl_offset_19; __gen_e_acsl_offset_19 = __e_acsl_offset((void *)q); __e_acsl_assert(__gen_e_acsl_offset_19 == 0UL,(char *)"Assertion", (char *)"main",(char *)"\\offset(q) == 0",49); } __e_acsl_full_init((void *)(& q)); q ++; /*@ assert \offset(q) ≡ sizeof(long); */ { unsigned long __gen_e_acsl_offset_20; __gen_e_acsl_offset_20 = __e_acsl_offset((void *)q); __e_acsl_assert(__gen_e_acsl_offset_20 == 8UL,(char *)"Assertion", (char *)"main",(char *)"\\offset(q) == sizeof(long)",51); } __e_acsl_full_init((void *)(& q)); q += 2; /*@ assert \offset(q) ≡ sizeof(long) * 3; */ { unsigned long __gen_e_acsl_offset_21; __gen_e_acsl_offset_21 = __e_acsl_offset((void *)q); __e_acsl_assert(__gen_e_acsl_offset_21 == 24UL,(char *)"Assertion", (char *)"main",(char *)"\\offset(q) == sizeof(long) * 3", 53); } __e_acsl_full_init((void *)(& q)); q += 4; /*@ assert \offset(q) ≡ sizeof(long) * 7; */ { unsigned long __gen_e_acsl_offset_22; __gen_e_acsl_offset_22 = __e_acsl_offset((void *)q); __e_acsl_assert(__gen_e_acsl_offset_22 == 56UL,(char *)"Assertion", (char *)"main",(char *)"\\offset(q) == sizeof(long) * 7", 55); } __retres = 0; __e_acsl_delete_block((void *)(& PA)); __e_acsl_delete_block((void *)(A)); __e_acsl_delete_block((void *)(& q)); __e_acsl_delete_block((void *)(& p)); __e_acsl_delete_block((void *)(& pi)); __e_acsl_delete_block((void *)(& pl)); __e_acsl_delete_block((void *)(& l)); __e_acsl_delete_block((void *)(a)); __e_acsl_memory_clean(); return __retres; }
void continue_valid(void) { int *p; int *q; __e_acsl_store_block((void *)(& q),(size_t)8); __e_acsl_store_block((void *)(& p),(size_t)8); int i = 0; while (1) { int tmp; tmp = i; i ++; ; if (! tmp) break; { /*@ assert ¬\valid(p); */ { int __gen_e_acsl_initialized; int __gen_e_acsl_and; __gen_e_acsl_initialized = __e_acsl_initialized((void *)(& p), sizeof(int *)); if (__gen_e_acsl_initialized) { int __gen_e_acsl_valid; __gen_e_acsl_valid = __e_acsl_valid((void *)p,sizeof(int), (void *)p,(void *)(& p)); __gen_e_acsl_and = __gen_e_acsl_valid; } else __gen_e_acsl_and = 0; __e_acsl_assert(! __gen_e_acsl_and,(char *)"Assertion", (char *)"continue_valid",(char *)"!\\valid(p)",130); } /*@ assert ¬\valid(q); */ { int __gen_e_acsl_initialized_2; int __gen_e_acsl_and_2; __gen_e_acsl_initialized_2 = __e_acsl_initialized((void *)(& q), sizeof(int *)); if (__gen_e_acsl_initialized_2) { int __gen_e_acsl_valid_2; __gen_e_acsl_valid_2 = __e_acsl_valid((void *)q,sizeof(int), (void *)q,(void *)(& q)); __gen_e_acsl_and_2 = __gen_e_acsl_valid_2; } else __gen_e_acsl_and_2 = 0; __e_acsl_assert(! __gen_e_acsl_and_2,(char *)"Assertion", (char *)"continue_valid",(char *)"!\\valid(q)",131); } int a1 = 1; __e_acsl_store_block((void *)(& a1),(size_t)4); __e_acsl_full_init((void *)(& a1)); __e_acsl_full_init((void *)(& p)); p = & a1; /*@ assert \valid(p); */ { int __gen_e_acsl_initialized_3; int __gen_e_acsl_and_3; __gen_e_acsl_initialized_3 = __e_acsl_initialized((void *)(& p), sizeof(int *)); if (__gen_e_acsl_initialized_3) { int __gen_e_acsl_valid_3; __gen_e_acsl_valid_3 = __e_acsl_valid((void *)p,sizeof(int), (void *)p,(void *)(& p)); __gen_e_acsl_and_3 = __gen_e_acsl_valid_3; } else __gen_e_acsl_and_3 = 0; __e_acsl_assert(__gen_e_acsl_and_3,(char *)"Assertion", (char *)"continue_valid",(char *)"\\valid(p)",135); } /*@ assert ¬\valid(q); */ { int __gen_e_acsl_initialized_4; int __gen_e_acsl_and_4; __gen_e_acsl_initialized_4 = __e_acsl_initialized((void *)(& q), sizeof(int *)); if (__gen_e_acsl_initialized_4) { int __gen_e_acsl_valid_4; __gen_e_acsl_valid_4 = __e_acsl_valid((void *)q,sizeof(int), (void *)q,(void *)(& q)); __gen_e_acsl_and_4 = __gen_e_acsl_valid_4; } else __gen_e_acsl_and_4 = 0; __e_acsl_assert(! __gen_e_acsl_and_4,(char *)"Assertion", (char *)"continue_valid",(char *)"!\\valid(q)",136); } { int a2 = 1; __e_acsl_store_block((void *)(& a2),(size_t)4); __e_acsl_full_init((void *)(& a2)); __e_acsl_full_init((void *)(& q)); q = & a2; /*@ assert \valid(p); */ { int __gen_e_acsl_initialized_5; int __gen_e_acsl_and_5; __gen_e_acsl_initialized_5 = __e_acsl_initialized((void *)(& p), sizeof(int *)); if (__gen_e_acsl_initialized_5) { int __gen_e_acsl_valid_5; __gen_e_acsl_valid_5 = __e_acsl_valid((void *)p,sizeof(int), (void *)p,(void *)(& p)); __gen_e_acsl_and_5 = __gen_e_acsl_valid_5; } else __gen_e_acsl_and_5 = 0; __e_acsl_assert(__gen_e_acsl_and_5,(char *)"Assertion", (char *)"continue_valid",(char *)"\\valid(p)",141); } /*@ assert \valid(q); */ { int __gen_e_acsl_initialized_6; int __gen_e_acsl_and_6; __gen_e_acsl_initialized_6 = __e_acsl_initialized((void *)(& q), sizeof(int *)); if (__gen_e_acsl_initialized_6) { int __gen_e_acsl_valid_6; __gen_e_acsl_valid_6 = __e_acsl_valid((void *)q,sizeof(int), (void *)q,(void *)(& q)); __gen_e_acsl_and_6 = __gen_e_acsl_valid_6; } else __gen_e_acsl_and_6 = 0; __e_acsl_assert(__gen_e_acsl_and_6,(char *)"Assertion", (char *)"continue_valid",(char *)"\\valid(q)",142); } __e_acsl_delete_block((void *)(& a1)); __e_acsl_delete_block((void *)(& a2)); continue; __e_acsl_delete_block((void *)(& a2)); } if (i == 5) { __e_acsl_delete_block((void *)(& a1)); break; } __e_acsl_delete_block((void *)(& a1)); } } /*@ assert ¬\valid(p); */ { int __gen_e_acsl_initialized_7; int __gen_e_acsl_and_7; __gen_e_acsl_initialized_7 = __e_acsl_initialized((void *)(& p), sizeof(int *)); if (__gen_e_acsl_initialized_7) { int __gen_e_acsl_valid_7; __gen_e_acsl_valid_7 = __e_acsl_valid((void *)p,sizeof(int),(void *)p, (void *)(& p)); __gen_e_acsl_and_7 = __gen_e_acsl_valid_7; } else __gen_e_acsl_and_7 = 0; __e_acsl_assert(! __gen_e_acsl_and_7,(char *)"Assertion", (char *)"continue_valid",(char *)"!\\valid(p)",150); } /*@ assert ¬\valid(q); */ { int __gen_e_acsl_initialized_8; int __gen_e_acsl_and_8; __gen_e_acsl_initialized_8 = __e_acsl_initialized((void *)(& q), sizeof(int *)); if (__gen_e_acsl_initialized_8) { int __gen_e_acsl_valid_8; __gen_e_acsl_valid_8 = __e_acsl_valid((void *)q,sizeof(int),(void *)q, (void *)(& q)); __gen_e_acsl_and_8 = __gen_e_acsl_valid_8; } else __gen_e_acsl_and_8 = 0; __e_acsl_assert(! __gen_e_acsl_and_8,(char *)"Assertion", (char *)"continue_valid",(char *)"!\\valid(q)",151); } __e_acsl_delete_block((void *)(& q)); __e_acsl_delete_block((void *)(& p)); return; }