* - BB base as object file offset
*/
static __inline__
-UInt bb_hash_idx(obj_node* obj, OffT offset, UInt size)
+UInt bb_hash_idx(obj_node* obj, PtrdiffT offset, UInt size)
{
return (((Addr)obj) + offset) % size;
}
* Not initialized:
* - instr_len, cost_count, instr[]
*/
-static BB* new_bb(obj_node* obj, OffT offset,
+static BB* new_bb(obj_node* obj, PtrdiffT offset,
UInt instr_count, UInt cjmp_count, Bool cjmp_inverted)
{
BB* new;
/* get the BB structure for a BB start address */
static __inline__
-BB* lookup_bb(obj_node* obj, OffT offset)
+BB* lookup_bb(obj_node* obj, PtrdiffT offset)
{
BB* bb;
Int idx;
{
obj_node* obj;
DebugInfo* di;
- OffT offset;
+ PtrdiffT offset;
di = VG_(find_seginfo)(addr);
obj = CLG_(get_obj_node)( di );
Int idx, size;
obj_node* obj = obj_of_address(addr);
- OffT offset = addr - obj->offset;
+ PtrdiffT offset = addr - obj->offset;
idx = bb_hash_idx(obj, offset, bbs.size);
bb = bbs.table[idx];
*/
struct _BB {
obj_node* obj; /* ELF object of BB */
- OffT offset; /* offset of BB in ELF object file */
+ PtrdiffT offset; /* offset of BB in ELF object file */
BB* next; /* chaining for a hash entry */
VgSectKind sect_kind; /* section of this BB, e.g. PLT */
Addr start; /* Start address of text segment mapping */
SizeT size; /* Length of mapping */
- OffT offset; /* Offset between symbol address and file offset */
+ PtrdiffT offset; /* Offset between symbol address and file offset */
file_node* files[N_FILE_ENTRIES];
UInt number;
Bool fromP; // AnonC, AnonV only: originated from PreAlloc?
UChar* fname; // MText, FileV only: filename
UChar* mname; // MText only: member name if present
- ULong offset; // FileV only: file offset
+ Off64T offset; // FileV only: file offset
}
AixSegment;
static void parse_procselfmaps (
void (*record_mapping)( Addr addr, SizeT len, UInt prot,
- ULong dev, ULong ino, ULong offset,
+ ULong dev, ULong ino, Off64T offset,
const UChar* filename ),
void (*record_gap)( Addr addr, SizeT len )
);
VG_(debugLog)(logLevel, "aspacem",
"NSegment{%s, start=0x%llx, end=0x%llx, smode=%s, dev=%llu, "
- "ino=%llu, offset=%llu, fnIdx=%d, hasR=%d, hasW=%d, hasX=%d, "
+ "ino=%llu, offset=%lld, fnIdx=%d, hasR=%d, hasW=%d, hasX=%d, "
"hasT=%d, mark=%d, name=\"%s\"}\n",
show_SegKind(seg->kind),
(ULong)seg->start,
seg->hasR ? 'r' : '-', seg->hasW ? 'w' : '-',
seg->hasX ? 'x' : '-', seg->hasT ? 'T' : '-',
seg->isCH ? 'H' : '-',
- seg->dev, seg->ino, (Long)seg->offset, seg->fnIdx
+ seg->dev, seg->ino, seg->offset, seg->fnIdx
);
break;
static Bool sync_check_ok = False;
static void sync_check_mapping_callback ( Addr addr, SizeT len, UInt prot,
- ULong dev, ULong ino, ULong offset,
+ ULong dev, ULong ino, Off64T offset,
const UChar* filename )
{
Int iLo, iHi, i;
/*-----------------------------------------------------------------*/
static void read_maps_callback ( Addr addr, SizeT len, UInt prot,
- ULong dev, ULong ino, ULong offset,
+ ULong dev, ULong ino, Off64T offset,
const UChar* filename )
{
NSegment seg;
*/
static void parse_procselfmaps (
void (*record_mapping)( Addr addr, SizeT len, UInt prot,
- ULong dev, ULong ino, ULong offset,
+ ULong dev, ULong ino, Off64T offset,
const UChar* filename ),
void (*record_gap)( Addr addr, SizeT len )
)
static
Bool get_sym_name ( Bool demangle, Addr a, Char* buf, Int nbuf,
Bool match_anywhere_in_sym, Bool show_offset,
- Bool findText, /*OUT*/OffT* offsetP )
+ Bool findText, /*OUT*/PtrdiffT* offsetP )
{
DebugInfo* di;
Word sno;
- Int offset;
+ PtrdiffT offset;
search_all_symtabs ( a, &di, &sno, match_anywhere_in_sym, findText );
if (di == NULL)
}
offset = a - di->symtab[sno].addr;
- if (offsetP) *offsetP = (OffT)offset;
+ if (offsetP) *offsetP = offset;
if (show_offset && offset != 0) {
Char buf2[12];
Char* end = buf + nbuf;
Int len;
- len = VG_(sprintf)(buf2, "%c%d",
+ len = VG_(sprintf)(buf2, "%c%ld",
offset < 0 ? '-' : '+',
offset < 0 ? -offset : offset);
vg_assert(len < (Int)sizeof(buf2));
from the symbol start is put into *offset. */
Bool VG_(get_datasym_and_offset)( Addr data_addr,
/*OUT*/Char* dname, Int n_dname,
- /*OUT*/OffT* offset )
+ /*OUT*/PtrdiffT* offset )
{
Bool ok;
vg_assert(n_dname > 1);
offset of data_addr from the start of the variable. Note that
regs, which supplies ip,sp,fp values, will be NULL for global
variables, and non-NULL for local variables. */
-static Bool data_address_is_in_var ( /*OUT*/UWord* offset,
+static Bool data_address_is_in_var ( /*OUT*/PtrdiffT* offset,
XArray* /* TyEnt */ tyents,
DiVariable* var,
RegSummary* regs,
Int n_dname,
Addr data_addr,
DiVariable* var,
- OffT var_offset,
- OffT residual_offset,
+ PtrdiffT var_offset,
+ PtrdiffT residual_offset,
XArray* /*UChar*/ described,
Int frameNo,
ThreadId tid )
&& VG_(sizeXA)(vars) > 0) );
for (j = 0; j < VG_(sizeXA)( vars ); j++) {
DiVariable* var = (DiVariable*)VG_(indexXA)( vars, j );
- SizeT offset;
+ PtrdiffT offset;
if (debug)
VG_(printf)("QQQQ: var:name=%s %#lx-%#lx %#lx\n",
var->name,arange->aMin,arange->aMax,ip);
if (data_address_is_in_var( &offset, di->admin_tyents,
var, ®s,
data_addr, di->data_bias )) {
- OffT residual_offset = 0;
+ PtrdiffT residual_offset = 0;
XArray* described = ML_(describe_type)( &residual_offset,
di->admin_tyents,
var->typeR, offset );
of any of them bracket data_addr. */
vars = global_arange->vars;
for (i = 0; i < VG_(sizeXA)( vars ); i++) {
- SizeT offset;
+ PtrdiffT offset;
DiVariable* var = (DiVariable*)VG_(indexXA)( vars, i );
vg_assert(var->name);
/* Note we use a NULL RegSummary* here. It can't make any
if (data_address_is_in_var( &offset, di->admin_tyents, var,
NULL/* RegSummary* */,
data_addr, di->data_bias )) {
- OffT residual_offset = 0;
+ PtrdiffT residual_offset = 0;
XArray* described = ML_(describe_type)( &residual_offset,
di->admin_tyents,
var->typeR, offset );
return di->filename;
}
-ULong VG_(seginfo_get_text_bias)(const DebugInfo* di)
+PtrdiffT VG_(seginfo_get_text_bias)(const DebugInfo* di)
{
return di->text_present ? di->text_bias : 0;
}
Stabs reader
-------------------- */
extern
-void ML_(read_debuginfo_stabs) ( struct _DebugInfo* di, OffT debug_offset,
+void ML_(read_debuginfo_stabs) ( struct _DebugInfo* di, PtrdiffT debug_offset,
UChar* stabC, Int stab_sz,
UChar* stabstr, Int stabstr_sz );
(4) is ensured by canonicaliseCFI.
*/
/* .text */
- Bool text_present;
- Addr text_avma;
- Addr text_svma;
- SizeT text_size;
- OffT text_bias;
+ Bool text_present;
+ Addr text_avma;
+ Addr text_svma;
+ SizeT text_size;
+ PtrdiffT text_bias;
/* .data */
- Bool data_present;
- Addr data_svma;
- Addr data_avma;
- SizeT data_size;
- OffT data_bias;
+ Bool data_present;
+ Addr data_svma;
+ Addr data_avma;
+ SizeT data_size;
+ PtrdiffT data_bias;
/* .sdata */
- Bool sdata_present;
- Addr sdata_svma;
- Addr sdata_avma;
- SizeT sdata_size;
- OffT sdata_bias;
+ Bool sdata_present;
+ Addr sdata_svma;
+ Addr sdata_avma;
+ SizeT sdata_size;
+ PtrdiffT sdata_bias;
/* .bss */
- Bool bss_present;
- Addr bss_svma;
- Addr bss_avma;
- SizeT bss_size;
- OffT bss_bias;
+ Bool bss_present;
+ Addr bss_svma;
+ Addr bss_avma;
+ SizeT bss_size;
+ PtrdiffT bss_bias;
/* .plt */
Bool plt_present;
Addr plt_avma;
/* Describe where in the type 'offset' falls. Caller must
deallocate the resulting XArray. */
-XArray* /*UChar*/ ML_(describe_type)( /*OUT*/OffT* residual_offset,
+XArray* /*UChar*/ ML_(describe_type)( /*OUT*/PtrdiffT* residual_offset,
XArray* /* of TyEnt */ tyents,
UWord ty_cuOff,
- OffT offset );
+ PtrdiffT offset );
/* A fast-lookup cache for ML_(TyEnts__index_by_cuOff). Nothing
typedef
struct {
/* FIXED */
- Addr rx_map_avma;
- SizeT rx_map_size;
- OffT text_bias;
+ Addr rx_map_avma;
+ SizeT rx_map_size;
+ PtrdiffT text_bias;
/* VARIABLE -- count stats */
UWord n_straightforward_biasings;
UWord n_kludgey_biasings;
Char* sym_name, /* name */
Addr sym_svma, /* address as stated in the object file */
UChar* opd_img, /* oimage of .opd sec (ppc64-linux only) */
- OffT opd_bias, /* for biasing AVMAs found in .opd */
+ PtrdiffT opd_bias, /* for biasing AVMAs found in .opd */
/* OUTPUTS */
Char** sym_name_out, /* name we should record */
Addr* sym_avma_out, /* addr we should record */
/* Read stabs-format debug info. This is all rather horrible because
stabs is a underspecified, kludgy hack.
*/
-void ML_(read_debuginfo_stabs) ( DebugInfo* di, OffT debug_offset,
+void ML_(read_debuginfo_stabs) ( DebugInfo* di, PtrdiffT debug_offset,
UChar* stabC, Int stab_sz,
UChar* stabstr, Int stabstr_sz )
{
VG_(addBytesToXA)( xa, buf, VG_(strlen)(buf));
}
-XArray* /*UChar*/ ML_(describe_type)( /*OUT*/OffT* residual_offset,
+XArray* /*UChar*/ ML_(describe_type)( /*OUT*/PtrdiffT* residual_offset,
XArray* /* of TyEnt */ tyents,
UWord ty_cuOff,
- OffT offset )
+ PtrdiffT offset )
{
TyEnt* ty;
XArray* xa = VG_(newXA)( ML_(dinfo_zalloc), "di.tytypes.dt.1",
XArray* fieldRs;
UWord fieldR;
TyEnt* field = NULL;
- OffT offMin = 0, offMax1 = 0;
+ PtrdiffT offMin = 0, offMax1 = 0;
if (!ty->Te.TyStOrUn.isStruct) goto done;
fieldRs = ty->Te.TyStOrUn.fieldRs;
if ((!fieldRs) || VG_(sizeXA)(fieldRs) == 0) goto done;
if (mul.b != True)
goto done; /* size of field is unknown (?!) */
offMin = res.word;
- offMax1 = offMin + (OffT)mul.ul;
+ offMax1 = offMin + (PtrdiffT)mul.ul;
if (offMin == offMax1)
continue;
vg_assert(offMin < offMax1);
return 0;
}
-SysRes VG_(pread) ( Int fd, void* buf, Int count, Int offset )
+SysRes VG_(pread) ( Int fd, void* buf, Int count, OffT offset )
{
OffT off = VG_(lseek)( fd, (OffT)offset, VKI_SEEK_SET);
if (off < 0)
void
VG_(get_shadow_regs_area) ( ThreadId tid,
/*DST*/UChar* dst,
- /*SRC*/Int shadowNo, OffT offset, SizeT size )
+ /*SRC*/Int shadowNo, PtrdiffT offset, SizeT size )
{
void* src;
ThreadState* tst;
void
VG_(set_shadow_regs_area) ( ThreadId tid,
- /*DST*/Int shadowNo, OffT offset, SizeT size,
+ /*DST*/Int shadowNo, PtrdiffT offset, SizeT size,
/*SRC*/const UChar* src )
{
void* dst;
/*--------------------------------------------------------------------*/
// The underscores avoid GCC complaints about overshadowing global names.
-AvlTree* VG_(OSetGen_Create)(OffT _keyOff, OSetCmp_t _cmp,
+AvlTree* VG_(OSetGen_Create)(PtrdiffT _keyOff, OSetCmp_t _cmp,
OSetAlloc_t _alloc, HChar* _cc,
OSetFree_t _free)
{
extern
void
ML_(notify_aspacem_and_tool_of_mmap) ( Addr a, SizeT len, UInt prot,
- UInt mm_flags, Int fd, ULong offset );
+ UInt mm_flags, Int fd, Off64T offset );
DECL_TEMPLATE(generic, sys_ni_syscall); // * P -- unimplemented
DEF0(track_pre_mem_write, CorePart, ThreadId, Char*, Addr, SizeT)
DEF0(track_post_mem_write, CorePart, ThreadId, Addr, SizeT)
-DEF0(track_pre_reg_read, CorePart, ThreadId, Char*, OffT, SizeT)
-DEF0(track_post_reg_write, CorePart, ThreadId, OffT, SizeT)
+DEF0(track_pre_reg_read, CorePart, ThreadId, Char*, PtrdiffT, SizeT)
+DEF0(track_post_reg_write, CorePart, ThreadId, PtrdiffT, SizeT)
-DEF0(track_post_reg_write_clientcall_return, ThreadId, OffT, SizeT, Addr)
+DEF0(track_post_reg_write_clientcall_return, ThreadId, PtrdiffT, SizeT, Addr)
DEF0(track_start_client_code, ThreadId, ULong)
DEF0(track_stop_client_code, ThreadId, ULong)
extern Int VG_(check_executable)(/*OUT*/Bool* is_setuid,
HChar* f, Bool allow_setuid);
-extern SysRes VG_(pread) ( Int fd, void* buf, Int count, Int offset );
+extern SysRes VG_(pread) ( Int fd, void* buf, Int count, OffT offset );
/* Create and open (-rw------) a tmp file name incorporating said arg.
Returns -1 on failure, else the fd of the file. If fullname is
void (*track_pre_mem_write) (CorePart, ThreadId, Char*, Addr, SizeT);
void (*track_post_mem_write) (CorePart, ThreadId, Addr, SizeT);
- void (*track_pre_reg_read) (CorePart, ThreadId, Char*, OffT, SizeT);
- void (*track_post_reg_write)(CorePart, ThreadId, OffT, SizeT);
- void (*track_post_reg_write_clientcall_return)(ThreadId, OffT, SizeT, Addr);
+ void (*track_pre_reg_read) (CorePart, ThreadId, Char*, PtrdiffT, SizeT);
+ void (*track_post_reg_write)(CorePart, ThreadId, PtrdiffT, SizeT);
+ void (*track_post_reg_write_clientcall_return)(ThreadId, PtrdiffT, SizeT,
+ Addr);
void (*track_start_client_code)(ThreadId, ULong);
void (*track_stop_client_code) (ThreadId, ULong);
struct { // Used by:
AddrKind akind; // ALL
SizeT size; // ALL
- OffT rwoffset; // ALL
+ PtrdiffT rwoffset; // ALL
ExeContext* lastchange; // Mallocd
DrdThreadId stack_tid; // Stack
DebugInfo* debuginfo; // Segment
/* these assume guest and host have the same endianness and
word size (probably). */
static UWord get_guest_intreg ( ThreadId tid, Int shadowNo,
- OffT offset, SizeT size )
+ PtrdiffT offset, SizeT size )
{
UChar tmp[ 2 + sizeof(UWord) ];
tl_assert(size == sizeof(UWord));
return * ((UWord*) &tmp[1] ); /* MISALIGNED LOAD */
}
static void put_guest_intreg ( ThreadId tid, Int shadowNo,
- OffT offset, SizeT size, UWord w )
+ PtrdiffT offset, SizeT size, UWord w )
{
tl_assert(size == sizeof(UWord));
tl_assert(0 == (offset % sizeof(UWord)));
}
}
-static void post_reg_write_nonptr ( ThreadId tid, OffT offset, SizeT size )
+static void post_reg_write_nonptr ( ThreadId tid, PtrdiffT offset, SizeT size )
{
// syscall_return: Default is non-pointer. If it really is a pointer
// (eg. for mmap()), SK_(post_syscall) sets it again afterwards.
}
static void post_reg_write_nonptr_or_unknown ( ThreadId tid,
- OffT offset, SizeT size )
+ PtrdiffT offset, SizeT size )
{
// deliver_signal: called from two places; one sets the reg to zero, the
// other sets the stack pointer.
}
void h_post_reg_write_demux ( CorePart part, ThreadId tid,
- OffT guest_state_offset, SizeT size)
+ PtrdiffT guest_state_offset, SizeT size)
{
if (0)
VG_(printf)("post_reg_write_demux: tid %d part %d off %ld size %ld\n",
}
}
-void h_post_reg_write_clientcall(ThreadId tid, OffT guest_state_offset,
+void h_post_reg_write_clientcall(ThreadId tid, PtrdiffT guest_state_offset,
SizeT size, Addr f )
{
UWord p;
Char* s, Addr lo );
void h_post_reg_write_demux ( CorePart part, ThreadId tid,
- OffT guest_state_offset, SizeT size);
-void h_post_reg_write_clientcall(ThreadId tid, OffT guest_state_offset,
+ PtrdiffT guest_state_offset, SizeT size);
+void h_post_reg_write_clientcall(ThreadId tid, PtrdiffT guest_state_offset,
SizeT size, Addr f );
void h_pre_syscall ( ThreadId tid, UInt syscallno );
HChar actual[128];
} SorG;
struct {
- Addr addr;
- SSizeT sszB; /* -ve is write, +ve is read */
- Seg* vseg;
- Char descr1[96];
- Char descr2[96];
- Char datasym[96];
- OffT datasymoff;
+ Addr addr;
+ SSizeT sszB; /* -ve is write, +ve is read */
+ Seg* vseg;
+ Char descr1[96];
+ Char descr2[96];
+ Char datasym[96];
+ PtrdiffT datasymoff;
} Heap;
struct {
Seg* seg1;
/* Associated file (SkFile{C,V} only) */
ULong dev;
ULong ino;
- ULong offset;
+ Off64T offset;
UInt mode;
Int fnIdx; // file name table index, if name is known
/* Permissions (SkAnon{C,V}, SkFile{C,V} only) */
// By choosing the right types, we can get these right for 32-bit and 64-bit
// platforms without having to do any conditional compilation or anything.
+// POSIX references:
+// - http://www.opengroup.org/onlinepubs/009695399/basedefs/sys/types.h.html
+// - http://www.opengroup.org/onlinepubs/009695399/basedefs/stddef.h.html
//
// Size in bits on: 32-bit archs 64-bit archs
// ------------ ------------
typedef unsigned long UWord; // 32 64
+typedef signed long Word; // 32 64
-typedef signed long Word; // 32 64
-
+// Addr is for holding an address. AddrH was intended to be "Addr on the
+// host", for the notional case where host word size != guest word size.
+// But since the assumption that host arch == guest arch has become so
+// deeply wired in, it's a pretty pointless distinction now.
typedef UWord Addr; // 32 64
typedef UWord AddrH; // 32 64
+// Our equivalents of POSIX 'size_t' and 'ssize_t':
+// - size_t is an "unsigned integer type of the result of the sizeof operator".
+// - ssize_t is "used for a count of bytes or an error indication".
typedef UWord SizeT; // 32 64
typedef Word SSizeT; // 32 64
-typedef Word OffT; // 32 64
-
-typedef ULong Off64T; // 64 64
+// Our equivalent of POSIX 'ptrdiff_t':
+// - ptrdiff_t is a "signed integer type of the result of subtracting two
+// pointers".
+// We use it for memory offsets, eg. the offset into a memory block.
+typedef Word PtrdiffT; // 32 64
+
+// Our equivalent of POSIX 'off_t':
+// - off_t is "used for file sizes".
+// At one point we were using it for memory offsets, but PtrdiffT should be
+// used in those cases.
+typedef Word OffT; // 32 64
+typedef Long Off64T; // 64 64
#if !defined(NULL)
# define NULL ((void*)0)
from the symbol start is put into *offset. */
extern Bool VG_(get_datasym_and_offset)( Addr data_addr,
/*OUT*/Char* dname, Int n_dname,
- /*OUT*/OffT* offset );
+ /*OUT*/PtrdiffT* offset );
/* Try to form some description of data_addr by looking at the DWARF3
debug info we have. This considers all global variables, and all
typedef
struct {
- OffT base; /* offset from sp or fp */
- SizeT szB; /* size in bytes */
- Bool spRel; /* True => sp-rel, False => fp-rel */
- Bool isVec; /* does block have an array type, or not? */
- HChar name[16]; /* first 15 chars of name (asciiz) */
+ PtrdiffT base; /* offset from sp or fp */
+ SizeT szB; /* size in bytes */
+ Bool spRel; /* True => sp-rel, False => fp-rel */
+ Bool isVec; /* does block have an array type, or not? */
+ HChar name[16]; /* first 15 chars of name (asciiz) */
}
StackBlock;
extern SizeT VG_(seginfo_get_gotplt_size)( const DebugInfo *di );
extern const UChar* VG_(seginfo_soname) ( const DebugInfo *di );
extern const UChar* VG_(seginfo_filename) ( const DebugInfo *di );
-extern ULong VG_(seginfo_get_text_bias)( const DebugInfo *di );
+extern PtrdiffT VG_(seginfo_get_text_bias)( const DebugInfo *di );
/* Function for traversing the seginfo list. When called with NULL it
returns the first element; otherwise it returns the given element's
void
VG_(get_shadow_regs_area) ( ThreadId tid,
/*DST*/UChar* dst,
- /*SRC*/Int shadowNo, OffT offset, SizeT size );
+ /*SRC*/Int shadowNo, PtrdiffT offset, SizeT size );
void
VG_(set_shadow_regs_area) ( ThreadId tid,
- /*DST*/Int shadowNo, OffT offset, SizeT size,
+ /*DST*/Int shadowNo, PtrdiffT offset, SizeT size,
/*SRC*/const UChar* src );
// Sets the shadow values for the syscall return value register(s).
// a deallocation function (such as VG_(free)()) directly will likely
// lead to assertions in Valgrind's allocator.
-extern OSet* VG_(OSetGen_Create) ( OffT keyOff, OSetCmp_t cmp,
+extern OSet* VG_(OSetGen_Create) ( PtrdiffT keyOff, OSetCmp_t cmp,
OSetAlloc_t alloc, HChar* ec,
OSetFree_t free );
extern void VG_(OSetGen_Destroy) ( OSet* os );
/* Register events. Use VG_(set_shadow_state_area)() to set the shadow regs
for these events. */
void VG_(track_pre_reg_read) (void(*f)(CorePart part, ThreadId tid,
- Char* s, OffT guest_state_offset,
+ Char* s, PtrdiffT guest_state_offset,
SizeT size));
void VG_(track_post_reg_write)(void(*f)(CorePart part, ThreadId tid,
- OffT guest_state_offset,
+ PtrdiffT guest_state_offset,
SizeT size));
/* This one is called for malloc() et al if they are replaced by a tool. */
void VG_(track_post_reg_write_clientcall_return)(
- void(*f)(ThreadId tid, OffT guest_state_offset, SizeT size, Addr f));
+ void(*f)(ThreadId tid, PtrdiffT guest_state_offset, SizeT size, Addr f));
/* Scheduler events (not exhaustive) */
BlockKind block_kind;
Char* block_desc; // "block", "mempool" or user-defined
SizeT block_szB;
- OffT rwoffset;
+ PtrdiffT rwoffset;
ExeContext* lastchange;
} Block;
- // In a global .data symbol. This holds the first 63 chars of
- // the variable's (zero terminated), plus an offset.
+ // In a global .data symbol. This holds the first 127 chars of
+ // the variable's name (zero terminated), plus a (memory) offset.
struct {
- Char name[128];
- OffT offset;
+ Char name[128];
+ PtrdiffT offset;
} DataSym;
// Is described by Dwarf debug info. Arbitrary strings. Must
break;
case Addr_Block: {
- SizeT block_szB = ai->Addr.Block.block_szB;
- OffT rwoffset = ai->Addr.Block.rwoffset;
- SizeT delta;
- const Char* relative;
+ SizeT block_szB = ai->Addr.Block.block_szB;
+ PtrdiffT rwoffset = ai->Addr.Block.rwoffset;
+ SizeT delta;
+ const Char* relative;
if (rwoffset < 0) {
delta = (SizeT)(-rwoffset);
big as the biggest guest state.
*/
static void mc_post_reg_write ( CorePart part, ThreadId tid,
- OffT offset, SizeT size)
+ PtrdiffT offset, SizeT size)
{
# define MAX_REG_WRITE_SIZE 1408
UChar area[MAX_REG_WRITE_SIZE];
static
void mc_post_reg_write_clientcall ( ThreadId tid,
- OffT offset, SizeT size,
- Addr f)
+ PtrdiffT offset, SizeT size, Addr f)
{
mc_post_reg_write(/*dummy*/0, tid, offset, size);
}
a parameter error.
*/
static void mc_pre_reg_read ( CorePart part, ThreadId tid, Char* s,
- OffT offset, SizeT size)
+ PtrdiffT offset, SizeT size)
{
Int i;
Bool bad;
projects / thirdparty / valgrind.git / commitdiff
