mirror of
https://github.com/Zenithsiz/ftmemsim-valgrind.git
synced 2026-02-04 02:18:37 +00:00
241 lines
8.4 KiB
C
241 lines
8.4 KiB
C
/*
|
|
This file is part of drd, a data race detector.
|
|
|
|
Copyright (C) 2006-2008 Bart Van Assche
|
|
bart.vanassche@gmail.com
|
|
|
|
This program is free software; you can redistribute it and/or
|
|
modify it under the terms of the GNU General Public License as
|
|
published by the Free Software Foundation; either version 2 of the
|
|
License, or (at your option) any later version.
|
|
|
|
This program is distributed in the hope that it will be useful, but
|
|
WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
|
|
General Public License for more details.
|
|
|
|
You should have received a copy of the GNU General Public License
|
|
along with this program; if not, write to the Free Software
|
|
Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA
|
|
02111-1307, USA.
|
|
|
|
The GNU General Public License is contained in the file COPYING.
|
|
*/
|
|
|
|
|
|
#ifndef __THREAD_H
|
|
#define __THREAD_H
|
|
|
|
|
|
/* Include directives. */
|
|
|
|
#include "drd_basics.h"
|
|
#include "drd_segment.h"
|
|
#include "pub_drd_bitmap.h"
|
|
#include "pub_tool_libcassert.h" // tl_assert()
|
|
#include "pub_tool_stacktrace.h" // StackTrace
|
|
#include "pub_tool_threadstate.h" // VG_N_THREADS
|
|
|
|
|
|
/* Defines. */
|
|
|
|
#define DRD_N_THREADS VG_N_THREADS
|
|
|
|
#define DRD_INVALID_THREADID 0
|
|
|
|
/* Note: the PThreadId typedef and the INVALID_POSIX_THREADID depend on the */
|
|
/* operating system and threading library in use. PThreadId must contain at */
|
|
/* least the same number of bits as pthread_t, and INVALID_POSIX_THREADID */
|
|
/* must be a value that will never be returned by pthread_self(). */
|
|
|
|
#define INVALID_POSIX_THREADID ((PThreadId)0)
|
|
|
|
|
|
/* Type definitions. */
|
|
|
|
typedef UWord PThreadId;
|
|
|
|
typedef struct
|
|
{
|
|
Segment* first;
|
|
Segment* last;
|
|
ThreadId vg_threadid;
|
|
PThreadId pt_threadid;
|
|
Addr stack_min_min; /**< Lowest value stack pointer ever had. */
|
|
Addr stack_min; /**< Current stack pointer. */
|
|
Addr stack_startup; /**<Stack pointer after pthread_create() finished.*/
|
|
Addr stack_max; /**< Top of stack. */
|
|
SizeT stack_size; /**< Maximum size of stack. */
|
|
/** Indicates whether the Valgrind core knows about this thread. */
|
|
Bool vg_thread_exists;
|
|
/** Indicates whether there is an associated POSIX thread ID. */
|
|
Bool posix_thread_exists;
|
|
/**
|
|
* If true, indicates that there is a corresponding POSIX thread ID and
|
|
* a corresponding OS thread that is detached.
|
|
*/
|
|
Bool detached_posix_thread;
|
|
/** Wether recording of memory accesses is active. */
|
|
Bool is_recording;
|
|
/** Nesting level of synchronization functions called by the client. */
|
|
Int synchr_nesting;
|
|
} ThreadInfo;
|
|
|
|
|
|
/*
|
|
* Local variables of drd_thread.c that are declared here such that these
|
|
* can be accessed by inline functions.
|
|
*/
|
|
|
|
extern DrdThreadId DRD_(g_drd_running_tid);
|
|
extern ThreadInfo DRD_(g_threadinfo)[DRD_N_THREADS];
|
|
extern struct bitmap* DRD_(g_conflict_set);
|
|
|
|
|
|
/* Function declarations. */
|
|
|
|
void thread_trace_context_switches(const Bool t);
|
|
void thread_trace_conflict_set(const Bool t);
|
|
Bool DRD_(thread_get_trace_fork_join)(void);
|
|
void DRD_(thread_set_trace_fork_join)(const Bool t);
|
|
void thread_set_segment_merging(const Bool m);
|
|
|
|
DrdThreadId VgThreadIdToDrdThreadId(const ThreadId tid);
|
|
DrdThreadId NewVgThreadIdToDrdThreadId(const ThreadId tid);
|
|
DrdThreadId PtThreadIdToDrdThreadId(const PThreadId tid);
|
|
ThreadId DrdThreadIdToVgThreadId(const DrdThreadId tid);
|
|
DrdThreadId thread_pre_create(const DrdThreadId creator,
|
|
const ThreadId vg_created);
|
|
DrdThreadId thread_post_create(const ThreadId vg_created);
|
|
void DRD_(thread_post_join)(DrdThreadId drd_joiner, DrdThreadId drd_joinee);
|
|
void thread_delete(const DrdThreadId tid);
|
|
void thread_finished(const DrdThreadId tid);
|
|
void thread_pre_cancel(const DrdThreadId tid);
|
|
void thread_set_stack_startup(const DrdThreadId tid, const Addr stack_startup);
|
|
Addr thread_get_stack_min(const DrdThreadId tid);
|
|
Addr thread_get_stack_min_min(const DrdThreadId tid);
|
|
Addr thread_get_stack_max(const DrdThreadId tid);
|
|
SizeT thread_get_stack_size(const DrdThreadId tid);
|
|
void thread_set_pthreadid(const DrdThreadId tid, const PThreadId ptid);
|
|
Bool thread_get_joinable(const DrdThreadId tid);
|
|
void thread_set_joinable(const DrdThreadId tid, const Bool joinable);
|
|
void thread_set_vg_running_tid(const ThreadId vg_tid);
|
|
void thread_set_running_tid(const ThreadId vg_tid,
|
|
const DrdThreadId drd_tid);
|
|
int thread_enter_synchr(const DrdThreadId tid);
|
|
int thread_leave_synchr(const DrdThreadId tid);
|
|
int thread_get_synchr_nesting_count(const DrdThreadId tid);
|
|
void thread_new_segment(const DrdThreadId tid);
|
|
VectorClock* thread_get_vc(const DrdThreadId tid);
|
|
void thread_get_latest_segment(Segment** sg, const DrdThreadId tid);
|
|
void thread_combine_vc(const DrdThreadId joiner, const DrdThreadId joinee);
|
|
void thread_combine_vc2(const DrdThreadId tid, const VectorClock* const vc);
|
|
|
|
void thread_stop_using_mem(const Addr a1, const Addr a2);
|
|
void thread_start_recording(const DrdThreadId tid);
|
|
void thread_stop_recording(const DrdThreadId tid);
|
|
void thread_print_all(void);
|
|
void thread_report_races(const DrdThreadId tid);
|
|
void thread_report_races_segment(const DrdThreadId tid,
|
|
const Segment* const p);
|
|
void thread_report_all_races(void);
|
|
void thread_report_conflicting_segments(const DrdThreadId tid,
|
|
const Addr addr,
|
|
const SizeT size,
|
|
const BmAccessTypeT access_type);
|
|
ULong thread_get_context_switch_count(void);
|
|
ULong thread_get_report_races_count(void);
|
|
ULong thread_get_discard_ordered_segments_count(void);
|
|
ULong thread_get_update_conflict_set_count(ULong* dsnsc, ULong* dscvc);
|
|
ULong thread_get_conflict_set_bitmap_creation_count(void);
|
|
ULong thread_get_conflict_set_bitmap2_creation_count(void);
|
|
|
|
|
|
/* Inline function definitions. */
|
|
|
|
static __inline__
|
|
Bool IsValidDrdThreadId(const DrdThreadId tid)
|
|
{
|
|
return (0 <= (int)tid && tid < DRD_N_THREADS && tid != DRD_INVALID_THREADID
|
|
&& ! (DRD_(g_threadinfo)[tid].vg_thread_exists == False
|
|
&& DRD_(g_threadinfo)[tid].posix_thread_exists == False
|
|
&& DRD_(g_threadinfo)[tid].detached_posix_thread == False));
|
|
}
|
|
|
|
static __inline__
|
|
DrdThreadId thread_get_running_tid(void)
|
|
{
|
|
tl_assert(DRD_(g_drd_running_tid) != DRD_INVALID_THREADID);
|
|
return DRD_(g_drd_running_tid);
|
|
}
|
|
|
|
static __inline__
|
|
struct bitmap* thread_get_conflict_set(void)
|
|
{
|
|
return DRD_(g_conflict_set);
|
|
}
|
|
|
|
static __inline__
|
|
Bool running_thread_is_recording(void)
|
|
{
|
|
#ifdef ENABLE_DRD_CONSISTENCY_CHECKS
|
|
tl_assert(0 <= (int)DRD_(g_drd_running_tid) && DRD_(g_drd_running_tid) < DRD_N_THREADS
|
|
&& DRD_(g_drd_running_tid) != DRD_INVALID_THREADID);
|
|
#endif
|
|
return (DRD_(g_threadinfo)[DRD_(g_drd_running_tid)].synchr_nesting == 0
|
|
&& DRD_(g_threadinfo)[DRD_(g_drd_running_tid)].is_recording);
|
|
}
|
|
|
|
static __inline__
|
|
void thread_set_stack_min(const DrdThreadId tid, const Addr stack_min)
|
|
{
|
|
#ifdef ENABLE_DRD_CONSISTENCY_CHECKS
|
|
tl_assert(0 <= (int)tid
|
|
&& tid < DRD_N_THREADS
|
|
&& tid != DRD_INVALID_THREADID);
|
|
#endif
|
|
DRD_(g_threadinfo)[tid].stack_min = stack_min;
|
|
#ifdef ENABLE_DRD_CONSISTENCY_CHECKS
|
|
/* This function can be called after the thread has been created but */
|
|
/* before drd_post_thread_create() has filled in stack_max. */
|
|
tl_assert(DRD_(g_threadinfo)[tid].stack_min < DRD_(g_threadinfo)[tid].stack_max
|
|
|| DRD_(g_threadinfo)[tid].stack_max == 0);
|
|
#endif
|
|
if (UNLIKELY(stack_min < DRD_(g_threadinfo)[tid].stack_min_min))
|
|
{
|
|
DRD_(g_threadinfo)[tid].stack_min_min = stack_min;
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Return true if and only if the specified address is on the stack of the
|
|
* currently scheduled thread.
|
|
*/
|
|
static __inline__
|
|
Bool thread_address_on_stack(const Addr a)
|
|
{
|
|
return (DRD_(g_threadinfo)[DRD_(g_drd_running_tid)].stack_min <= a
|
|
&& a < DRD_(g_threadinfo)[DRD_(g_drd_running_tid)].stack_max);
|
|
}
|
|
|
|
/** Return a pointer to the latest segment for the specified thread. */
|
|
static __inline__
|
|
Segment* thread_get_segment(const DrdThreadId tid)
|
|
{
|
|
#ifdef ENABLE_DRD_CONSISTENCY_CHECKS
|
|
tl_assert(0 <= (int)tid && tid < DRD_N_THREADS
|
|
&& tid != DRD_INVALID_THREADID);
|
|
tl_assert(DRD_(g_threadinfo)[tid].last);
|
|
#endif
|
|
return DRD_(g_threadinfo)[tid].last;
|
|
}
|
|
|
|
/** Return a pointer to the latest segment for the running thread. */
|
|
static __inline__
|
|
Segment* running_thread_get_segment(void)
|
|
{
|
|
return thread_get_segment(DRD_(g_drd_running_tid));
|
|
}
|
|
|
|
#endif // __THREAD_H
|