inline void fclose_cleanup(void *stream)
{
__CPROVER_HIDE:;
__CPROVER_assert(!__CPROVER_get_must(stream, "open") ||
__CPROVER_get_must(stream, "closed"),
"resource leak: fopen file not closed");
}
inline int pthread_cond_wait(
pthread_cond_t *cond,
pthread_mutex_t *mutex)
{ __CPROVER_HIDE:
(void)*mutex;
#ifdef __CPROVER_CUSTOM_BITVECTOR_ANALYSIS
__CPROVER_assert(__CPROVER_get_must(mutex, "mutex-init"),
"mutex must be initialized");
__CPROVER_assert(__CPROVER_get_must(mutex, "mutex-locked"),
"mutex must be locked");
__CPROVER_assert(!__CPROVER_get_may(mutex, "mutex-destroyed"),
"mutex must not be destroyed");
__CPROVER_clear_may(mutex, "mutex-locked");
#endif
__CPROVER_atomic_begin();
__CPROVER_assume(*((unsigned *)cond));
(*((unsigned *)cond))--;
__CPROVER_atomic_end();
return 0; // we never fail
}
inline int pthread_mutex_unlock(pthread_mutex_t *mutex)
{
__CPROVER_HIDE:;
#ifdef __CPROVER_CUSTOM_BITVECTOR_ANALYSIS
__CPROVER_assert(__CPROVER_get_must(mutex, "mutex-init"),
"mutex must be initialized");
__CPROVER_assert(__CPROVER_get_must(mutex, "mutex-locked"),
"mutex must be locked");
__CPROVER_assert(!__CPROVER_get_may(mutex, "mutex-destroyed"),
"mutex must not be destroyed");
__CPROVER_clear_may(mutex, "mutex-locked");
#else
// the fence must be before the unlock
__CPROVER_fence("WWfence", "RRfence", "RWfence", "WRfence",
"WWcumul", "RRcumul", "RWcumul", "WRcumul");
__CPROVER_atomic_begin();
__CPROVER_assert(*((__CPROVER_mutex_t *)mutex)==1,
"must hold lock upon unlock");
*((__CPROVER_mutex_t *)mutex)=0;
__CPROVER_atomic_end();
#endif
return 0; // we never fail
}
inline int pthread_mutex_lock(pthread_mutex_t *mutex)
{
__CPROVER_HIDE:;
#ifdef __CPROVER_CUSTOM_BITVECTOR_ANALYSIS
__CPROVER_assert(__CPROVER_get_must(mutex, "mutex-init"),
"mutex must be initialized");
__CPROVER_assert(!__CPROVER_get_may(mutex, "mutex-destroyed"),
"mutex must not be destroyed");
__CPROVER_assert(__CPROVER_get_must(mutex, "mutex-recursive") ||
!__CPROVER_get_may(mutex, "mutex-locked"),
"attempt to lock non-recurisive locked mutex");
__CPROVER_set_must(mutex, "mutex-locked");
__CPROVER_set_may(mutex, "mutex-locked");
__CPROVER_assert(*((__CPROVER_mutex_t *)mutex)!=-1,
"mutex not initialised or destroyed");
#else
__CPROVER_atomic_begin();
__CPROVER_assume(!*((__CPROVER_mutex_t *)mutex));
*((__CPROVER_mutex_t *)mutex)=1;
__CPROVER_atomic_end();
__CPROVER_fence("WWfence", "RRfence", "RWfence", "WRfence",
"WWcumul", "RRcumul", "RWcumul", "WRcumul");
#endif
return 0; // we never fail
}
inline int pthread_mutex_destroy(pthread_mutex_t *mutex)
{
__CPROVER_HIDE:;
#ifdef __CPROVER_CUSTOM_BITVECTOR_ANALYSIS
__CPROVER_assert(__CPROVER_get_must(mutex, "mutex-init"),
"mutex must be initialized");
__CPROVER_assert(!__CPROVER_get_may(mutex, "mutex-locked"),
"mutex must not be locked");
__CPROVER_assert(!__CPROVER_get_may(mutex, "mutex-destroyed"),
"mutex must not be destroyed");
__CPROVER_set_must(mutex, "mutex-destroyed");
__CPROVER_set_may(mutex, "mutex-destroyed");
#else
__CPROVER_assert(*((__CPROVER_mutex_t *)mutex)==0,
"lock held upon destroy");
*((__CPROVER_mutex_t *)mutex)=-1;
#endif
return 0;
}
inline char *fgets(char *str, int size, FILE *stream)
{
__CPROVER_HIDE:;
__CPROVER_bool error;
(void)size;
(void)*stream;
#ifdef __CPROVER_CUSTOM_BITVECTOR_ANALYSIS
__CPROVER_assert(__CPROVER_get_must(stream, "open"),
"fgets file must be open");
#endif
#ifdef __CPROVER_STRING_ABSTRACTION
int resulting_size;
__CPROVER_assert(__CPROVER_buffer_size(str)>=size, "buffer-overflow in fgets");
if(size>0)
{
__CPROVER_assume(resulting_size<size);
__CPROVER_is_zero_string(str)=!error;
__CPROVER_zero_string_length(str)=resulting_size;
}
#endif
return error?0:str;
}
inline size_t fread(
void *ptr,
size_t size,
size_t nitems,
FILE *stream)
{
__CPROVER_HIDE:;
size_t nread;
size_t bytes=nread*size;
size_t i;
__CPROVER_assume(nread<=nitems);
(void)*stream;
#ifdef __CPROVER_CUSTOM_BITVECTOR_ANALYSIS
__CPROVER_assert(__CPROVER_get_must(stream, "open"),
"fread file must be open");
#endif
for(i=0; i<bytes; i++)
{
char nondet_char;
((char *)ptr)[i]=nondet_char;
}
return nread;
}
inline void pthread_mutex_cleanup(void *p)
{
__CPROVER_HIDE:;
__CPROVER_assert(
__CPROVER_get_must(p, "mutex-destroyed"),
"mutex must be destroyed");
}
inline int pthread_mutex_trylock(pthread_mutex_t *mutex)
{
__CPROVER_HIDE:;
int return_value;
__CPROVER_atomic_begin();
#ifdef __CPROVER_CUSTOM_BITVECTOR_ANALYSIS
__CPROVER_assert(__CPROVER_get_must(mutex, "mutex-init"),
"mutex must be initialized");
__CPROVER_assert(*((__CPROVER_mutex_t *)mutex)!=-1,
"mutex not initialised or destroyed");
#endif
if(*((__CPROVER_mutex_t *)mutex)==1)
{
// failed
return_value=1;
}
else
{
// ok
return_value=0;
*((__CPROVER_mutex_t *)mutex)=1;
}
__CPROVER_atomic_end();
__CPROVER_fence("WWfence", "RRfence", "RWfence", "WRfence",
"WWcumul", "RRcumul", "RWcumul", "WRcumul");
return return_value;
}
void rewind(FILE *stream)
{
__CPROVER_HIDE:
(void)*stream;
#ifdef __CPROVER_CUSTOM_BITVECTOR_ANALYSIS
__CPROVER_assert(__CPROVER_get_must(stream, "open"),
"rewind file must be open");
#endif
}
inline long ftell(FILE *stream)
{
__CPROVER_HIDE:;
int return_value;
(void)*stream;
#ifdef __CPROVER_CUSTOM_BITVECTOR_ANALYSIS
__CPROVER_assert(__CPROVER_get_must(stream, "open"),
"ftell file must be open");
#endif
return return_value;
}
inline int pthread_cancel(pthread_t thread)
{
__CPROVER_HIDE:;
(void)thread;
#ifdef __CPROVER_CUSTOM_BITVECTOR_ANALYSIS
__CPROVER_assert(__CPROVER_get_must(&thread, "pthread-id"),
"pthread_cancel must be given valid thread ID");
#endif
int result;
return result;
}
inline int fclose(FILE *stream)
{
__CPROVER_HIDE:;
#ifdef __CPROVER_CUSTOM_BITVECTOR_ANALYSIS
__CPROVER_assert(__CPROVER_get_must(stream, "open"),
"fclose file must be open");
__CPROVER_clear_must(stream, "open");
__CPROVER_set_must(stream, "closed");
#endif
int return_value;
free(stream);
return return_value;
}
inline int getw(FILE *stream)
{
__CPROVER_HIDE:;
int return_value;
(void)*stream;
#ifdef __CPROVER_CUSTOM_BITVECTOR_ANALYSIS
__CPROVER_assert(__CPROVER_get_must(stream, "open"),
"getw file must be open");
#endif
// it's any int, no restriction
return return_value;
}
inline int fpurge(FILE *stream)
{
// just return nondet
__CPROVER_HIDE:;
int return_value;
(void)*stream;
#ifdef __CPROVER_CUSTOM_BITVECTOR_ANALYSIS
__CPROVER_assert(__CPROVER_get_must(stream, "open"),
"fpurge file must be open");
#endif
return return_value;
}
inline int fseek(FILE *stream, long offset, int whence)
{
__CPROVER_HIDE:;
int return_value;
(void)*stream;
(void)offset;
(void)whence;
#ifdef __CPROVER_CUSTOM_BITVECTOR_ANALYSIS
__CPROVER_assert(__CPROVER_get_must(stream, "open"),
"fseek file must be open");
#endif
return return_value;
}
inline int getc(FILE *stream)
{
__CPROVER_HIDE:;
int return_value;
(void)*stream;
#ifdef __CPROVER_CUSTOM_BITVECTOR_ANALYSIS
__CPROVER_assert(__CPROVER_get_must(stream, "open"),
"getc file must be open");
#endif
// It's a byte or EOF, which we fix to -1.
__CPROVER_assume(return_value>=-1 && return_value<=255);
return return_value;
}
inline int fgetc(FILE *stream)
{
__CPROVER_HIDE:;
int return_value;
(void)*stream;
// it's a byte or EOF (-1)
__CPROVER_assume(return_value>=-1 && return_value<=255);
#ifdef __CPROVER_CUSTOM_BITVECTOR_ANALYSIS
__CPROVER_assert(__CPROVER_get_must(stream, "open"),
"fgetc file must be open");
#endif
return return_value;
}
inline int _pthread_join(pthread_t thread, void **value_ptr)
{
__CPROVER_HIDE:;
#ifdef __CPROVER_CUSTOM_BITVECTOR_ANALYSIS
__CPROVER_assert(__CPROVER_get_must(&thread, "pthread-id"),
"phtread_join must be given valid thread ID");
#endif
if((unsigned long)thread>__CPROVER_next_thread_id) return ESRCH;
if((unsigned long)thread==__CPROVER_thread_id) return EDEADLK;
if(value_ptr!=0) (void)**(char**)value_ptr;
__CPROVER_assume(__CPROVER_threads_exited[(unsigned long)thread]);
return 0;
}
inline int pthread_barrier_wait(pthread_barrier_t *barrier)
{
__CPROVER_HIDE:;
(void)barrier;
#ifdef __CPROVER_CUSTOM_BITVECTOR_ANALYSIS
__CPROVER_assert(__CPROVER_get_must(barrier, "barrier-init"),
"pthread barrier must be initialized");
__CPROVER_assert(!__CPROVER_get_may(barrier, "barrier-destroyed"),
"pthread barrier must not be destroyed");
#endif
int result;
return result;
}
inline int pthread_mutex_init(
pthread_mutex_t *mutex, const pthread_mutexattr_t *mutexattr)
{
__CPROVER_HIDE:;
*((__CPROVER_mutex_t *)mutex)=0;
if(mutexattr!=0) (void)*mutexattr;
#ifdef __CPROVER_CUSTOM_BITVECTOR_ANALYSIS
__CPROVER_cleanup(mutex, pthread_mutex_cleanup);
__CPROVER_set_must(mutex, "mutex-init");
__CPROVER_clear_may(mutex, "mutex-destroyed");
if(__CPROVER_get_must(mutexattr, "mutexattr-recursive"))
__CPROVER_set_must(mutex, "mutex-recursive");
#endif
return 0;
}
inline int fputs(const char *s, FILE *stream)
{
// just return nondet
__CPROVER_HIDE:;
int return_value;
#ifdef __CPROVER_STRING_ABSTRACTION
__CPROVER_assert(__CPROVER_is_zero_string(s), "fputs zero-termination of 1st argument");
#endif
(void)*s;
(void)*stream;
#ifdef __CPROVER_CUSTOM_BITVECTOR_ANALYSIS
__CPROVER_assert(__CPROVER_get_must(stream, "open"),
"fputs file must be open");
#endif
return return_value;
}
size_t fwrite(
const void *ptr,
size_t size,
size_t nitems,
FILE *stream)
{
__CPROVER_HIDE:;
(void)*(char*)ptr;
(void)size;
(void)*stream;
#ifdef __CPROVER_CUSTOM_BITVECTOR_ANALYSIS
__CPROVER_assert(__CPROVER_get_must(stream, "open"),
"fwrite file must be open");
#endif
size_t nwrite;
__CPROVER_assume(nwrite<=nitems);
return nwrite;
}
inline void pthread_rwlock_cleanup(void *p)
{
__CPROVER_HIDE:;
__CPROVER_assert(__CPROVER_get_must(p, "rwlock_destroyed"),
"rwlock must be destroyed");
}
