maxjhandsome
/
llvm-project
forked from OSchip/llvm-project
1
0
Fork 0
Code Issues Pull Requests Packages Releases Wiki Activity

<rdar://problem/13069948> 

Major fixed to allow reading files that are over 4GB. The main problems were that the DataExtractor was using 32 bit offsets as a data cursor, and since we mmap all of our object files we could run into cases where if we had a very large core file that was over 4GB, we were running into the 4GB boundary.

So I defined a new "lldb::offset_t" which should be used for all file offsets.

After making this change, I enabled warnings for data loss and for enexpected implicit conversions temporarily and found a ton of things that I fixed.

Any functions that take an index internally, should use "size_t" for any indexes and also should return "size_t" for any sizes of collections.

llvm-svn: 173463
This commit is contained in:
Greg Clayton 2013-01-25 18:06:21 +00:00
parent d0ed6c249d
commit c7bece56fa
248 changed files with 1676 additions and 1817 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

3
lldb/examples/python/operating_system.py
View File

@ -25,8 +25,9 @@ class OperatingSystemPlugIn(object):
return self.process.target
def create_thread(self, tid, context):
print 'tid type is: ' + str(type(tid))
if tid == 0x444444444:
thread_info = { 'tid' : 0x444444444, 'name' : 'four' , 'queue' : 'queue4', 'state' : 'stopped', 'stop_reason' : 'none' }
thread_info = { 'tid' : tid, 'name' : 'four' , 'queue' : 'queue4', 'state' : 'stopped', 'stop_reason' : 'none' }
self.threads.append(thread_info)
return thread_info
return None

28
lldb/include/lldb/API/SBData.h
View File

@ -49,47 +49,47 @@ public:
SetByteOrder (lldb::ByteOrder endian);
float
GetFloat (lldb::SBError& error, uint32_t offset);
GetFloat (lldb::SBError& error, lldb::offset_t offset);
double
GetDouble (lldb::SBError& error, uint32_t offset);
GetDouble (lldb::SBError& error, lldb::offset_t offset);
long double
GetLongDouble (lldb::SBError& error, uint32_t offset);
GetLongDouble (lldb::SBError& error, lldb::offset_t offset);
lldb::addr_t
GetAddress (lldb::SBError& error, uint32_t offset);
GetAddress (lldb::SBError& error, lldb::offset_t offset);
uint8_t
GetUnsignedInt8 (lldb::SBError& error, uint32_t offset);
GetUnsignedInt8 (lldb::SBError& error, lldb::offset_t offset);
uint16_t
GetUnsignedInt16 (lldb::SBError& error, uint32_t offset);
GetUnsignedInt16 (lldb::SBError& error, lldb::offset_t offset);
uint32_t
GetUnsignedInt32 (lldb::SBError& error, uint32_t offset);
GetUnsignedInt32 (lldb::SBError& error, lldb::offset_t offset);
uint64_t
GetUnsignedInt64 (lldb::SBError& error, uint32_t offset);
GetUnsignedInt64 (lldb::SBError& error, lldb::offset_t offset);
int8_t
GetSignedInt8 (lldb::SBError& error, uint32_t offset);
GetSignedInt8 (lldb::SBError& error, lldb::offset_t offset);
int16_t
GetSignedInt16 (lldb::SBError& error, uint32_t offset);
GetSignedInt16 (lldb::SBError& error, lldb::offset_t offset);
int32_t
GetSignedInt32 (lldb::SBError& error, uint32_t offset);
GetSignedInt32 (lldb::SBError& error, lldb::offset_t offset);
int64_t
GetSignedInt64 (lldb::SBError& error, uint32_t offset);
GetSignedInt64 (lldb::SBError& error, lldb::offset_t offset);
const char*
GetString (lldb::SBError& error, uint32_t offset);
GetString (lldb::SBError& error, lldb::offset_t offset);
size_t
ReadRawData (lldb::SBError& error,
uint32_t offset,
lldb::offset_t offset,
void *buf,
size_t size);

4
lldb/include/lldb/Breakpoint/Breakpoint.h
View File

@ -136,7 +136,7 @@ public:
static lldb::BreakpointLocationSP
GetBreakpointLocationAtIndexFromEvent (const lldb::EventSP &event_sp, uint32_t loc_idx);
static uint32_t
static size_t
GetNumBreakpointLocationsFromEvent (const lldb::EventSP &event_sp);
static const BreakpointEventData *
@ -310,7 +310,7 @@ public:
/// greater than then number of actual locations.
//------------------------------------------------------------------
lldb::BreakpointLocationSP
GetLocationAtIndex (uint32_t index);
GetLocationAtIndex (size_t index);
//------------------------------------------------------------------
// The next section deals with various breakpoint options.

12
lldb/include/lldb/Breakpoint/BreakpointIDList.h
View File

@ -41,10 +41,10 @@ public:
GetSize();
BreakpointID &
GetBreakpointIDAtIndex (uint32_t index);
GetBreakpointIDAtIndex (size_t index);
bool
RemoveBreakpointIDAtIndex (uint32_t index);
RemoveBreakpointIDAtIndex (size_t index);
void
Clear();
@ -56,16 +56,16 @@ public:
AddBreakpointID (const char *bp_id);
bool
FindBreakpointID (BreakpointID &bp_id, uint32_t *position);
FindBreakpointID (BreakpointID &bp_id, size_t *position);
bool
FindBreakpointID (const char *bp_id, uint32_t *position);
FindBreakpointID (const char *bp_id, size_t *position);
void
InsertStringArray (const char **string_array, uint32_t array_size, CommandReturnObject &result);
InsertStringArray (const char **string_array, size_t array_size, CommandReturnObject &result);
static bool
StringContainsIDRangeExpression (const char *in_string, uint32_t *range_start_len, uint32_t *range_end_pos);
StringContainsIDRangeExpression (const char *in_string, size_t *range_start_len, size_t *range_end_pos);
static void
FindAndReplaceIDRanges (Args &old_args, Target *target, CommandReturnObject &result, Args &new_args);

4
lldb/include/lldb/Breakpoint/BreakpointList.h
View File

@ -92,7 +92,7 @@ public:
/// breakpoint doesn't exist.
//------------------------------------------------------------------
lldb::BreakpointSP
GetBreakpointAtIndex (uint32_t i);
GetBreakpointAtIndex (size_t i);
//------------------------------------------------------------------
/// Returns a shared pointer to the breakpoint with index \a i, const version
@ -105,7 +105,7 @@ public:
/// breakpoint doesn't exist.
//------------------------------------------------------------------
const lldb::BreakpointSP
GetBreakpointAtIndex (uint32_t i) const;
GetBreakpointAtIndex (size_t i) const;
//------------------------------------------------------------------
/// Returns the number of elements in this breakpoint list.

4
lldb/include/lldb/Breakpoint/BreakpointLocationCollection.h
View File

@ -101,7 +101,7 @@ public:
/// pointer if the breakpoint doesn't exist.
//------------------------------------------------------------------
lldb::BreakpointLocationSP
GetByIndex (uint32_t i);
GetByIndex (size_t i);
//------------------------------------------------------------------
/// Returns a shared pointer to the breakpoint location with index
@ -115,7 +115,7 @@ public:
/// pointer if the breakpoint doesn't exist.
//------------------------------------------------------------------
const lldb::BreakpointLocationSP
GetByIndex (uint32_t i) const;
GetByIndex (size_t i) const;
//------------------------------------------------------------------
/// Returns the number of elements in this breakpoint location list.

4
lldb/include/lldb/Breakpoint/BreakpointLocationList.h
View File

@ -119,7 +119,7 @@ public:
/// pointer if the breakpoint doesn't exist.
//------------------------------------------------------------------
lldb::BreakpointLocationSP
GetByIndex (uint32_t i);
GetByIndex (size_t i);
//------------------------------------------------------------------
/// Returns a shared pointer to the breakpoint location with index
@ -133,7 +133,7 @@ public:
/// pointer if the breakpoint doesn't exist.
//------------------------------------------------------------------
const lldb::BreakpointLocationSP
GetByIndex (uint32_t i) const;
GetByIndex (size_t i) const;
//------------------------------------------------------------------
/// Removes all the locations in this list from their breakpoint site

9
lldb/include/lldb/Breakpoint/BreakpointSite.h
View File

@ -83,7 +83,7 @@ public:
//------------------------------------------------------------------
bool
SetTrapOpcode (const uint8_t *trap_opcode,
size_t trap_opcode_size);
uint32_t trap_opcode_size);
//------------------------------------------------------------------
/// Gets the original instruction bytes that were overwritten by the trap
@ -168,7 +168,7 @@ public:
/// @return
/// The number of owners.
//------------------------------------------------------------------
uint32_t
size_t
GetNumberOfOwners ();
//------------------------------------------------------------------
@ -183,7 +183,7 @@ public:
/// A shared pointer to the breakpoint location at that index.
//------------------------------------------------------------------
lldb::BreakpointLocationSP
GetOwnerAtIndex (uint32_t index);
GetOwnerAtIndex (size_t idx);
//------------------------------------------------------------------
/// Check whether the owners of this breakpoint site have any
@ -244,7 +244,7 @@ private:
/// @param[in] context
/// \a break_loc_id is the Breakpoint Location to remove.
//------------------------------------------------------------------
uint32_t
size_t
RemoveOwner (lldb::break_id_t break_id,
lldb::break_id_t break_loc_id);
@ -265,7 +265,6 @@ private:
BreakpointSite (BreakpointSiteList *list,
const lldb::BreakpointLocationSP& owner,
lldb::addr_t m_addr,
lldb::tid_t tid,
bool use_hardware);
DISALLOW_COPY_AND_ASSIGN(BreakpointSite);

2
lldb/include/lldb/Breakpoint/Watchpoint.h
View File

@ -76,7 +76,7 @@ public:
DISALLOW_COPY_AND_ASSIGN (WatchpointEventData);
};
Watchpoint (Target& target, lldb::addr_t addr, size_t size, const ClangASTType *type, bool hardware = true);
Watchpoint (Target& target, lldb::addr_t addr, uint32_t size, const ClangASTType *type, bool hardware = true);
~Watchpoint ();
void

2
lldb/include/lldb/Core/ArchSpec.h
View File

@ -159,7 +159,7 @@ public:
const ArchSpec&
operator= (const ArchSpec& rhs);
static uint32_t
static size_t
AutoComplete (const char *name,
StringList &matches);

26
lldb/include/lldb/Core/CXXFormatterFunctions.h
View File

@ -135,11 +135,11 @@ namespace lldb_private {
public:
NSArrayMSyntheticFrontEnd (lldb::ValueObjectSP valobj_sp);
virtual uint32_t
virtual size_t
CalculateNumChildren ();
virtual lldb::ValueObjectSP
GetChildAtIndex (uint32_t idx);
GetChildAtIndex (size_t idx);
virtual bool
Update();
@ -166,11 +166,11 @@ namespace lldb_private {
public:
NSArrayISyntheticFrontEnd (lldb::ValueObjectSP valobj_sp);
virtual uint32_t
virtual size_t
CalculateNumChildren ();
virtual lldb::ValueObjectSP
GetChildAtIndex (uint32_t idx);
GetChildAtIndex (size_t idx);
virtual bool
Update();
@ -186,7 +186,7 @@ namespace lldb_private {
private:
ExecutionContextRef m_exe_ctx_ref;
uint8_t m_ptr_size;
uint64_t m_items;
size_t m_items;
lldb::addr_t m_data_ptr;
ClangASTType m_id_type;
std::vector<lldb::ValueObjectSP> m_children;
@ -197,11 +197,11 @@ namespace lldb_private {
public:
NSArrayCodeRunningSyntheticFrontEnd (lldb::ValueObjectSP valobj_sp);
virtual uint32_t
virtual size_t
CalculateNumChildren ();
virtual lldb::ValueObjectSP
GetChildAtIndex (uint32_t idx);
GetChildAtIndex (size_t idx);
virtual bool
Update();
@ -242,11 +242,11 @@ namespace lldb_private {
public:
NSDictionaryISyntheticFrontEnd (lldb::ValueObjectSP valobj_sp);
virtual uint32_t
virtual size_t
CalculateNumChildren ();
virtual lldb::ValueObjectSP
GetChildAtIndex (uint32_t idx);
GetChildAtIndex (size_t idx);
virtual bool
Update();
@ -298,11 +298,11 @@ namespace lldb_private {
public:
NSDictionaryMSyntheticFrontEnd (lldb::ValueObjectSP valobj_sp);
virtual uint32_t
virtual size_t
CalculateNumChildren ();
virtual lldb::ValueObjectSP
GetChildAtIndex (uint32_t idx);
GetChildAtIndex (size_t idx);
virtual bool
Update();
@ -328,11 +328,11 @@ namespace lldb_private {
public:
NSDictionaryCodeRunningSyntheticFrontEnd (lldb::ValueObjectSP valobj_sp);
virtual uint32_t
virtual size_t
CalculateNumChildren ();
virtual lldb::ValueObjectSP
GetChildAtIndex (uint32_t idx);
GetChildAtIndex (size_t idx);
virtual bool
Update();

134
lldb/include/lldb/Core/DataExtractor.h
View File

@ -86,7 +86,7 @@ public:
/// @param[in] addr_size
/// A new address byte size value.
//------------------------------------------------------------------
DataExtractor (const void* data, uint32_t data_length, lldb::ByteOrder byte_order, uint8_t addr_size);
DataExtractor (const void* data, lldb::offset_t data_length, lldb::ByteOrder byte_order, uint32_t addr_size);
//------------------------------------------------------------------
/// Construct with shared data.
@ -105,7 +105,7 @@ public:
/// @param[in] addr_size
/// A new address byte size value.
//------------------------------------------------------------------
DataExtractor (const lldb::DataBufferSP& data_sp, lldb::ByteOrder byte_order, uint8_t addr_size);
DataExtractor (const lldb::DataBufferSP& data_sp, lldb::ByteOrder byte_order, uint32_t addr_size);
//------------------------------------------------------------------
/// Construct with a subset of \a data.
@ -130,7 +130,7 @@ public:
/// @param[in] length
/// The length in bytes of the subset of data.
//------------------------------------------------------------------
DataExtractor (const DataExtractor& data, uint32_t offset, uint32_t length);
DataExtractor (const DataExtractor& data, lldb::offset_t offset, lldb::offset_t length);
DataExtractor (const DataExtractor& rhs);
//------------------------------------------------------------------
@ -204,10 +204,10 @@ public:
/// @return
/// The offset at which dumping ended.
//------------------------------------------------------------------
uint32_t
lldb::offset_t
PutToLog (Log *log,
uint32_t offset,
uint32_t length,
lldb::offset_t offset,
lldb::offset_t length,
uint64_t base_addr,
uint32_t num_per_line,
Type type,
@ -273,13 +273,13 @@ public:
/// @return
/// The offset at which dumping ended.
//------------------------------------------------------------------
uint32_t
lldb::offset_t
Dump (Stream *s,
uint32_t offset,
lldb::offset_t offset,
lldb::Format item_format,
uint32_t item_byte_size,
uint32_t item_count,
uint32_t num_per_line,
size_t item_byte_size,
size_t item_count,
size_t num_per_line,
uint64_t base_addr,
uint32_t item_bit_size,
uint32_t item_bit_offset,
@ -300,7 +300,7 @@ public:
/// UUID value.
//------------------------------------------------------------------
void
DumpUUID (Stream *s, uint32_t offset) const;
DumpUUID (Stream *s, lldb::offset_t offset) const;
//------------------------------------------------------------------
/// Extract an arbitrary number of bytes in the specified byte
@ -332,7 +332,7 @@ public:
/// if there aren't enough bytes at the specified offset.
//------------------------------------------------------------------
size_t
ExtractBytes (uint32_t offset, uint32_t length, lldb::ByteOrder dst_byte_order, void *dst) const;
ExtractBytes (lldb::offset_t offset, lldb::offset_t length, lldb::ByteOrder dst_byte_order, void *dst) const;
//------------------------------------------------------------------
/// Extract an address from \a *offset_ptr.
@ -353,10 +353,10 @@ public:
/// The extracted address value.
//------------------------------------------------------------------
uint64_t
GetAddress (uint32_t *offset_ptr) const;
GetAddress (lldb::offset_t *offset_ptr) const;
uint64_t
GetAddress_unchecked (uint32_t *offset_ptr) const;
GetAddress_unchecked (lldb::offset_t *offset_ptr) const;
//------------------------------------------------------------------
/// Get the current address size.
@ -367,7 +367,7 @@ public:
/// @return
/// The size in bytes of address values that will be extracted.
//------------------------------------------------------------------
uint8_t
uint32_t
GetAddressByteSize () const
{
return m_addr_size;
@ -379,7 +379,7 @@ public:
/// @return
/// The total number of bytes of data this object refers to.
//------------------------------------------------------------------
size_t
uint64_t
GetByteSize () const
{
return m_end - m_start;
@ -408,7 +408,7 @@ public:
/// NULL will be returned.
//------------------------------------------------------------------
const char *
GetCStr (uint32_t *offset_ptr) const;
GetCStr (lldb::offset_t *offset_ptr) const;
//------------------------------------------------------------------
/// Extract \a length bytes from \a *offset_ptr.
@ -434,7 +434,7 @@ public:
/// and length are valid, or NULL otherwise.
//------------------------------------------------------------------
const void*
GetData (uint32_t *offset_ptr, uint32_t length) const;
GetData (lldb::offset_t *offset_ptr, lldb::offset_t length) const;
//------------------------------------------------------------------
/// Copy \a dst_len bytes from \a *offset_ptr and ensure the copied
@ -475,11 +475,11 @@ public:
/// Returns the number of bytes that were copied, or zero if
/// anything goes wrong.
//------------------------------------------------------------------
uint32_t
CopyByteOrderedData (uint32_t src_offset,
uint32_t src_len,
lldb::offset_t
CopyByteOrderedData (lldb::offset_t src_offset,
lldb::offset_t src_len,
void *dst,
uint32_t dst_len,
lldb::offset_t dst_len,
lldb::ByteOrder dst_byte_order) const;
//------------------------------------------------------------------
@ -538,13 +538,13 @@ public:
/// The floating value that was extracted, or zero on failure.
//------------------------------------------------------------------
float
GetFloat (uint32_t *offset_ptr) const;
GetFloat (lldb::offset_t *offset_ptr) const;
double
GetDouble (uint32_t *offset_ptr) const;
GetDouble (lldb::offset_t *offset_ptr) const;
long double
GetLongDouble (uint32_t *offset_ptr) const;
GetLongDouble (lldb::offset_t *offset_ptr) const;
//------------------------------------------------------------------
/// Extract a GNU encoded pointer value from \a *offset_ptr.
@ -575,7 +575,11 @@ public:
/// The extracted GNU encoded pointer value.
//------------------------------------------------------------------
uint64_t
GetGNUEHPointer (uint32_t *offset_ptr, uint32_t eh_ptr_enc, lldb::addr_t pc_rel_addr, lldb::addr_t text_addr, lldb::addr_t data_addr);
GetGNUEHPointer (lldb::offset_t *offset_ptr,
uint32_t eh_ptr_enc,
lldb::addr_t pc_rel_addr,
lldb::addr_t text_addr,
lldb::addr_t data_addr);
//------------------------------------------------------------------
/// Extract an integer of size \a byte_size from \a *offset_ptr.
@ -601,7 +605,7 @@ public:
/// The integer value that was extracted, or zero on failure.
//------------------------------------------------------------------
uint32_t
GetMaxU32 (uint32_t *offset_ptr, uint32_t byte_size) const;
GetMaxU32 (lldb::offset_t *offset_ptr, size_t byte_size) const;
//------------------------------------------------------------------
/// Extract an unsigned integer of size \a byte_size from \a
@ -630,10 +634,10 @@ public:
/// failure.
//------------------------------------------------------------------
uint64_t
GetMaxU64 (uint32_t *offset_ptr, uint32_t byte_size) const;
GetMaxU64 (lldb::offset_t *offset_ptr, size_t byte_size) const;
uint64_t
GetMaxU64_unchecked (uint32_t *offset_ptr, uint32_t byte_size) const;
GetMaxU64_unchecked (lldb::offset_t *offset_ptr, size_t byte_size) const;
//------------------------------------------------------------------
/// Extract an signed integer of size \a byte_size from \a *offset_ptr.
@ -661,7 +665,7 @@ public:
/// or zero on failure.
//------------------------------------------------------------------
int64_t
GetMaxS64 (uint32_t *offset_ptr, uint32_t size) const;
GetMaxS64 (lldb::offset_t *offset_ptr, size_t size) const;
//------------------------------------------------------------------
/// Extract an unsigned integer of size \a byte_size from \a
@ -700,7 +704,10 @@ public:
/// zero on failure.
//------------------------------------------------------------------
uint64_t
GetMaxU64Bitfield (uint32_t *offset_ptr, uint32_t size, uint32_t bitfield_bit_size, uint32_t bitfield_bit_offset) const;
GetMaxU64Bitfield (lldb::offset_t *offset_ptr,
size_t size,
uint32_t bitfield_bit_size,
uint32_t bitfield_bit_offset) const;
//------------------------------------------------------------------
/// Extract an signed integer of size \a byte_size from \a
@ -739,7 +746,10 @@ public:
/// zero on failure.
//------------------------------------------------------------------
int64_t
GetMaxS64Bitfield (uint32_t *offset_ptr, uint32_t size, uint32_t bitfield_bit_size, uint32_t bitfield_bit_offset) const;
GetMaxS64Bitfield (lldb::offset_t *offset_ptr,
size_t size,
uint32_t bitfield_bit_size,
uint32_t bitfield_bit_offset) const;
//------------------------------------------------------------------
/// Extract an pointer from \a *offset_ptr.
@ -760,7 +770,7 @@ public:
/// The extracted pointer value as a 64 integer.
//------------------------------------------------------------------
uint64_t
GetPointer (uint32_t *offset_ptr) const;
GetPointer (lldb::offset_t *offset_ptr) const;
//------------------------------------------------------------------
/// Get the current byte order value.
@ -792,10 +802,10 @@ public:
/// The extracted uint8_t value.
//------------------------------------------------------------------
uint8_t
GetU8 ( uint32_t *offset_ptr) const;
GetU8 ( lldb::offset_t *offset_ptr) const;
uint8_t
GetU8_unchecked (uint32_t *offset_ptr) const
GetU8_unchecked (lldb::offset_t *offset_ptr) const
{
uint8_t val = m_start[*offset_ptr];
*offset_ptr += 1;
@ -803,13 +813,13 @@ public:
}
uint16_t
GetU16_unchecked (uint32_t *offset_ptr) const;
GetU16_unchecked (lldb::offset_t *offset_ptr) const;
uint32_t
GetU32_unchecked (uint32_t *offset_ptr) const;
GetU32_unchecked (lldb::offset_t *offset_ptr) const;
uint64_t
GetU64_unchecked (uint32_t *offset_ptr) const;
GetU64_unchecked (lldb::offset_t *offset_ptr) const;
//------------------------------------------------------------------
/// Extract \a count uint8_t values from \a *offset_ptr.
///
@ -836,7 +846,7 @@ public:
/// NULL otherise.
//------------------------------------------------------------------
void *
GetU8 ( uint32_t *offset_ptr, void *dst, uint32_t count) const;
GetU8 (lldb::offset_t *offset_ptr, void *dst, uint32_t count) const;
//------------------------------------------------------------------
/// Extract a uint16_t value from \a *offset_ptr.
@ -855,7 +865,7 @@ public:
/// The extracted uint16_t value.
//------------------------------------------------------------------
uint16_t
GetU16 (uint32_t *offset_ptr) const;
GetU16 (lldb::offset_t *offset_ptr) const;
//------------------------------------------------------------------
/// Extract \a count uint16_t values from \a *offset_ptr.
@ -883,7 +893,7 @@ public:
/// NULL otherise.
//------------------------------------------------------------------
void *
GetU16 (uint32_t *offset_ptr, void *dst, uint32_t count) const;
GetU16 (lldb::offset_t *offset_ptr, void *dst, uint32_t count) const;
//------------------------------------------------------------------
/// Extract a uint32_t value from \a *offset_ptr.
@ -902,7 +912,7 @@ public:
/// The extracted uint32_t value.
//------------------------------------------------------------------
uint32_t
GetU32 (uint32_t *offset_ptr) const;
GetU32 (lldb::offset_t *offset_ptr) const;
//------------------------------------------------------------------
/// Extract \a count uint32_t values from \a *offset_ptr.
@ -930,7 +940,7 @@ public:
/// NULL otherise.
//------------------------------------------------------------------
void *
GetU32 (uint32_t *offset_ptr, void *dst, uint32_t count) const;
GetU32 (lldb::offset_t *offset_ptr, void *dst, uint32_t count) const;
//------------------------------------------------------------------
/// Extract a uint64_t value from \a *offset_ptr.
@ -949,7 +959,7 @@ public:
/// The extracted uint64_t value.
//------------------------------------------------------------------
uint64_t
GetU64 (uint32_t *offset_ptr) const;
GetU64 (lldb::offset_t *offset_ptr) const;
//------------------------------------------------------------------
/// Extract \a count uint64_t values from \a *offset_ptr.
@ -977,7 +987,7 @@ public:
/// NULL otherise.
//------------------------------------------------------------------
void *
GetU64 ( uint32_t *offset_ptr, void *dst, uint32_t count) const;
GetU64 ( lldb::offset_t *offset_ptr, void *dst, uint32_t count) const;
//------------------------------------------------------------------
/// Extract a signed LEB128 value from \a *offset_ptr.
@ -998,7 +1008,7 @@ public:
/// The extracted signed integer value.
//------------------------------------------------------------------
int64_t
GetSLEB128 (uint32_t *offset_ptr) const;
GetSLEB128 (lldb::offset_t *offset_ptr) const;
//------------------------------------------------------------------
/// Extract a unsigned LEB128 value from \a *offset_ptr.
@ -1019,7 +1029,7 @@ public:
/// The extracted unsigned integer value.
//------------------------------------------------------------------
uint64_t
GetULEB128 (uint32_t *offset_ptr) const;
GetULEB128 (lldb::offset_t *offset_ptr) const;
lldb::DataBufferSP &
GetSharedDataBuffer ()
@ -1042,7 +1052,7 @@ public:
/// NULL otherwise.
//------------------------------------------------------------------
const char *
PeekCStr (uint32_t offset) const;
PeekCStr (lldb::offset_t offset) const;
//------------------------------------------------------------------
/// Peek at a bytes at \a offset.
@ -1056,7 +1066,7 @@ public:
/// otherwise.
//------------------------------------------------------------------
const uint8_t*
PeekData (uint32_t offset, uint32_t length) const;
PeekData (lldb::offset_t offset, lldb::offset_t length) const;
//------------------------------------------------------------------
/// Set the address byte size.
@ -1068,7 +1078,7 @@ public:
/// The size in bytes to use when extracting addresses.
//------------------------------------------------------------------
void
SetAddressByteSize (uint8_t addr_size)
SetAddressByteSize (uint32_t addr_size)
{
m_addr_size = addr_size;
}
@ -1094,8 +1104,8 @@ public:
/// @return
/// The number of bytes that this object now contains.
//------------------------------------------------------------------
uint32_t
SetData (const void *bytes, uint32_t length, lldb::ByteOrder byte_order);
lldb::offset_t
SetData (const void *bytes, lldb::offset_t length, lldb::ByteOrder byte_order);
//------------------------------------------------------------------
/// Adopt a subset of \a data.
@ -1123,8 +1133,8 @@ public:
/// @return
/// The number of bytes that this object now contains.
//------------------------------------------------------------------
uint32_t
SetData (const DataExtractor& data, uint32_t offset, uint32_t length);
lldb::offset_t
SetData (const DataExtractor& data, lldb::offset_t offset, lldb::offset_t length);
//------------------------------------------------------------------
/// Adopt a subset of shared data in \a data_sp.
@ -1151,8 +1161,8 @@ public:
/// @return
/// The number of bytes that this object now contains.
//------------------------------------------------------------------
uint32_t
SetData (const lldb::DataBufferSP& data_sp, uint32_t offset = 0, uint32_t length = UINT32_MAX);
lldb::offset_t
SetData (const lldb::DataBufferSP& data_sp, lldb::offset_t offset = 0, lldb::offset_t length = LLDB_INVALID_OFFSET);
//------------------------------------------------------------------
/// Set the byte_order value.
@ -1188,7 +1198,7 @@ public:
// The number of bytes consumed during the extraction.
//------------------------------------------------------------------
uint32_t
Skip_LEB128 (uint32_t *offset_ptr) const;
Skip_LEB128 (lldb::offset_t *offset_ptr) const;
//------------------------------------------------------------------
/// Test the validity of \a offset.
@ -1198,7 +1208,7 @@ public:
/// object, \b false otherwise.
//------------------------------------------------------------------
bool
ValidOffset (uint32_t offset) const
ValidOffset (lldb::offset_t offset) const
{
return offset < GetByteSize();
}
@ -1211,7 +1221,7 @@ public:
/// length bytes available at that offset, \b false otherwise.
//------------------------------------------------------------------
bool
ValidOffsetForDataOfSize (uint32_t offset, uint32_t length) const;
ValidOffsetForDataOfSize (lldb::offset_t offset, lldb::offset_t length) const;
size_t
Copy (DataExtractor& dest_data) const;
@ -1220,7 +1230,7 @@ public:
Append (DataExtractor& rhs);
bool
Append (void* bytes, uint32_t length);
Append (void* bytes, lldb::offset_t length);
protected:
//------------------------------------------------------------------
@ -1229,7 +1239,7 @@ protected:
const uint8_t * m_start; ///< A pointer to the first byte of data.
const uint8_t * m_end; ///< A pointer to the byte that is past the end of the data.
lldb::ByteOrder m_byte_order; ///< The byte order of the data we are extracting from.
uint8_t m_addr_size; ///< The address size to use when extracting pointers or addresses
uint32_t m_addr_size; ///< The address size to use when extracting pointers or addresses
mutable lldb::DataBufferSP m_data_sp; ///< The shared pointer to data that can be shared among multilple instances
};

4
lldb/include/lldb/Core/Debugger.h
View File

@ -227,11 +227,11 @@ public:
static lldb::DebuggerSP
FindDebuggerWithInstanceName (const ConstString &instance_name);
static uint32_t
static size_t
GetNumDebuggers();
static lldb::DebuggerSP
GetDebuggerAtIndex (uint32_t);
GetDebuggerAtIndex (size_t index);
static bool
FormatPrompt (const char *format,

12
lldb/include/lldb/Core/Disassembler.h
View File

@ -88,8 +88,8 @@ public:
virtual size_t
Decode (const Disassembler &disassembler,
const DataExtractor& data,
uint32_t data_offset) = 0;
const DataExtractor& data,
lldb::offset_t data_offset) = 0;
virtual void
SetDescription (const char *) {} // May be overridden in sub-classes that have descriptions.
@ -166,7 +166,7 @@ public:
GetMaxOpcocdeByteSize () const;
lldb::InstructionSP
GetInstructionAtIndex (uint32_t idx) const;
GetInstructionAtIndex (size_t idx) const;
uint32_t
GetIndexOfNextBranchInstruction(uint32_t start) const;
@ -218,7 +218,7 @@ public:
virtual size_t
Decode (const Disassembler &disassembler,
const DataExtractor &data,
uint32_t data_offset);
lldb::offset_t data_offset);
void
SetOpcode (size_t opcode_size, void *opcode_data);
@ -350,8 +350,8 @@ public:
virtual size_t
DecodeInstructions (const Address &base_addr,
const DataExtractor& data,
uint32_t data_offset,
uint32_t num_instructions,
lldb::offset_t data_offset,
size_t num_instructions,
bool append) = 0;
InstructionList &

16
lldb/include/lldb/Core/FileSpecList.h
View File

@ -123,8 +123,8 @@ public:
/// The index of the file that matches \a file if it is found,
/// else UINT32_MAX is returned.
//------------------------------------------------------------------
uint32_t
FindFileIndex (uint32_t idx, const FileSpec &file, bool full) const;
size_t
FindFileIndex (size_t idx, const FileSpec &file, bool full) const;
//------------------------------------------------------------------
/// Get file at index.
@ -143,7 +143,7 @@ public:
/// returned.
//------------------------------------------------------------------
const FileSpec &
GetFileSpecAtIndex (uint32_t idx) const;
GetFileSpecAtIndex (size_t idx) const;
//------------------------------------------------------------------
/// Get file specification pointer at index.
@ -159,7 +159,7 @@ public:
/// If \a idx is out of range, then an NULL is returned.
//------------------------------------------------------------------
const FileSpec *
GetFileSpecPointerAtIndex (uint32_t idx) const;
GetFileSpecPointerAtIndex (size_t idx) const;
//------------------------------------------------------------------
/// Get the memory cost of this object.
@ -182,11 +182,11 @@ public:
/// @return
/// The number of files in the file spec list.
//------------------------------------------------------------------
uint32_t
size_t
GetSize () const;
bool
Insert (uint32_t idx, const FileSpec &file)
Insert (size_t idx, const FileSpec &file)
{
if (idx < m_files.size())
{
@ -202,7 +202,7 @@ public:
}
bool
Replace (uint32_t idx, const FileSpec &file)
Replace (size_t idx, const FileSpec &file)
{
if (idx < m_files.size())
{
@ -213,7 +213,7 @@ public:
}
bool
Remove (uint32_t idx)
Remove (size_t idx)
{
if (idx < m_files.size())
{

22
lldb/include/lldb/Core/FormatClasses.h
View File

@ -237,11 +237,11 @@ public:
{
}
virtual uint32_t
virtual size_t
CalculateNumChildren () = 0;
virtual lldb::ValueObjectSP
GetChildAtIndex (uint32_t idx) = 0;
GetChildAtIndex (size_t idx) = 0;
virtual uint32_t
GetIndexOfChildWithName (const ConstString &name) = 0;
@ -479,14 +479,14 @@ public:
m_expression_paths.clear();
}
int
size_t
GetCount() const
{
return m_expression_paths.size();
}
const char*
GetExpressionPathAtIndex(int i) const
GetExpressionPathAtIndex(size_t i) const
{
return m_expression_paths[i].c_str();
}
@ -556,14 +556,14 @@ public:
{
}
virtual uint32_t
virtual size_t
CalculateNumChildren()
{
return filter->GetCount();
}
virtual lldb::ValueObjectSP
GetChildAtIndex (uint32_t idx)
GetChildAtIndex (size_t idx)
{
if (idx >= filter->GetCount())
return lldb::ValueObjectSP();
@ -720,7 +720,7 @@ public:
virtual
~FrontEnd();
virtual uint32_t
virtual size_t
CalculateNumChildren()
{
if (!m_wrapper_sp || m_interpreter == NULL)
@ -729,7 +729,7 @@ public:
}
virtual lldb::ValueObjectSP
GetChildAtIndex (uint32_t idx);
GetChildAtIndex (size_t idx);
virtual bool
Update()
@ -911,7 +911,7 @@ public:
}
int
GetRealIndexForIndex(int i);
GetRealIndexForIndex(size_t i);
bool
IsScripted()
@ -939,7 +939,7 @@ public:
{
}
virtual uint32_t
virtual size_t
CalculateNumChildren()
{
return filter->GetCount();
@ -952,7 +952,7 @@ public:
}
virtual lldb::ValueObjectSP
GetChildAtIndex (uint32_t idx)
GetChildAtIndex (size_t idx)
{
if (idx >= filter->GetCount())
return lldb::ValueObjectSP();

20
lldb/include/lldb/Core/FormatManager.h
View File

@ -150,7 +150,7 @@ public:
#endif
lldb::TypeNameSpecifierImplSP
GetTypeNameSpecifierForSummaryAtIndex (uint32_t index)
GetTypeNameSpecifierForSummaryAtIndex (size_t index)
{
if (index < m_summary_nav->GetCount())
return m_summary_nav->GetTypeNameSpecifierAtIndex(index);
@ -159,7 +159,7 @@ public:
}
SummaryNavigator::MapValueType
GetSummaryAtIndex (uint32_t index)
GetSummaryAtIndex (size_t index)
{
if (index < m_summary_nav->GetCount())
return m_summary_nav->GetAtIndex(index);
@ -168,7 +168,7 @@ public:
}
FilterNavigator::MapValueType
GetFilterAtIndex (uint32_t index)
GetFilterAtIndex (size_t index)
{
if (index < m_filter_nav->GetCount())
return m_filter_nav->GetAtIndex(index);
@ -177,7 +177,7 @@ public:
}
lldb::TypeNameSpecifierImplSP
GetTypeNameSpecifierForFilterAtIndex (uint32_t index)
GetTypeNameSpecifierForFilterAtIndex (size_t index)
{
if (index < m_filter_nav->GetCount())
return m_filter_nav->GetTypeNameSpecifierAtIndex(index);
@ -199,7 +199,7 @@ public:
}
SynthNavigator::MapValueType
GetSyntheticAtIndex (uint32_t index)
GetSyntheticAtIndex (size_t index)
{
if (index < m_synth_nav->GetCount())
return m_synth_nav->GetAtIndex(index);
@ -208,7 +208,7 @@ public:
}
lldb::TypeNameSpecifierImplSP
GetTypeNameSpecifierForSyntheticAtIndex (uint32_t index)
GetTypeNameSpecifierForSyntheticAtIndex (size_t index)
{
if (index < m_synth_nav->GetCount())
return m_synth_nav->GetTypeNameSpecifierAtIndex(index);
@ -486,7 +486,7 @@ public:
LoopThrough (CallbackType callback, void* param);
lldb::TypeCategoryImplSP
GetAtIndex (uint32_t);
GetAtIndex (size_t index);
bool
AnyMatches (ConstString type_name,
@ -495,7 +495,7 @@ public:
const char** matching_category = NULL,
TypeCategoryImpl::FormatCategoryItems* matching_type = NULL);
uint32_t
size_t
GetCount ()
{
return m_map.size();
@ -615,14 +615,14 @@ public:
return m_categories_map.Clear();
}
uint32_t
size_t
GetCategoriesCount ()
{
return m_categories_map.GetCount();
}
lldb::TypeCategoryImplSP
GetCategoryAtIndex (uint32_t index)
GetCategoryAtIndex (size_t index)
{
return m_categories_map.GetAtIndex(index);
}

16
lldb/include/lldb/Core/FormatNavigator.h
View File

@ -185,14 +185,14 @@ public:
}
}
uint32_t
size_t
GetCount ()
{
return m_map.size();
}
ValueSP
GetValueAtIndex (uint32_t index)
GetValueAtIndex (size_t index)
{
Mutex::Locker locker(m_map_mutex);
MapIterator iter = m_map.begin();
@ -208,7 +208,7 @@ public:
}
KeyType
GetKeyAtIndex (uint32_t index)
GetKeyAtIndex (size_t index)
{
Mutex::Locker locker(m_map_mutex);
MapIterator iter = m_map.begin();
@ -316,13 +316,13 @@ public:
}
MapValueType
GetAtIndex (uint32_t index)
GetAtIndex (size_t index)
{
return m_format_map.GetValueAtIndex(index);
}
lldb::TypeNameSpecifierImplSP
GetTypeNameSpecifierAtIndex (uint32_t index)
GetTypeNameSpecifierAtIndex (size_t index)
{
return GetTypeNameSpecifierAtIndex_Impl(index, (KeyType*)NULL);
}
@ -339,7 +339,7 @@ public:
m_format_map.LoopThrough(callback,param);
}
uint32_t
size_t
GetCount ()
{
return m_format_map.GetCount();
@ -405,7 +405,7 @@ protected:
}
lldb::TypeNameSpecifierImplSP
GetTypeNameSpecifierAtIndex_Impl (uint32_t index, ConstString *dummy)
GetTypeNameSpecifierAtIndex_Impl (size_t index, ConstString *dummy)
{
ConstString key = m_format_map.GetKeyAtIndex(index);
if (key)
@ -416,7 +416,7 @@ protected:
}
lldb::TypeNameSpecifierImplSP
GetTypeNameSpecifierAtIndex_Impl (uint32_t index, lldb::RegularExpressionSP *dummy)
GetTypeNameSpecifierAtIndex_Impl (size_t index, lldb::RegularExpressionSP *dummy)
{
lldb::RegularExpressionSP regex = m_format_map.GetKeyAtIndex(index);
if (regex.get() == NULL)

24
lldb/include/lldb/Core/MappedHash.h
View File

@ -36,7 +36,7 @@ public:
}
static uint32_t
HashString (const uint8_t hash_function, const char *s)
HashString (uint32_t hash_function, const char *s)
{
switch (hash_function)
{
@ -115,8 +115,8 @@ public:
s.Printf ("header.header_data_len = 0x%8.8x %u\n", header_data_len, header_data_len);
}
virtual uint32_t
Read (lldb_private::DataExtractor &data, uint32_t offset)
virtual lldb::offset_t
Read (lldb_private::DataExtractor &data, lldb::offset_t offset)
{
if (data.ValidOffsetForDataOfSize (offset,
sizeof (magic) +
@ -140,14 +140,14 @@ public:
data.SetByteOrder(lldb::eByteOrderBig);
break;
default:
return UINT32_MAX;
return LLDB_INVALID_OFFSET;
}
}
else
{
// Magic bytes didn't match
version = 0;
return UINT32_MAX;
return LLDB_INVALID_OFFSET;
}
}
@ -155,7 +155,7 @@ public:
if (version != 1)
{
// Unsupported version
return UINT32_MAX;
return LLDB_INVALID_OFFSET;
}
hash_function = data.GetU16 (&offset);
if (hash_function == 4)
@ -165,7 +165,7 @@ public:
header_data_len = data.GetU32 (&offset);
return offset;
}
return UINT32_MAX;
return LLDB_INVALID_OFFSET;
}
//
// // Returns a buffer that contains a serialized version of this table
@ -379,8 +379,8 @@ public:
m_hash_values (NULL),
m_hash_offsets (NULL)
{
uint32_t offset = m_header.Read (data, 0);
if (offset != UINT32_MAX && IsValid ())
lldb::offset_t offset = m_header.Read (data, 0);
if (offset != LLDB_INVALID_OFFSET && IsValid ())
{
m_hash_indexes = (uint32_t *)data.GetData (&offset, m_header.bucket_count * sizeof(uint32_t));
m_hash_values = (uint32_t *)data.GetData (&offset, m_header.hashes_count * sizeof(uint32_t));
@ -443,10 +443,10 @@ public:
const uint32_t curr_hash_value = GetHashValue (hash_idx);
if (curr_hash_value == hash_value)
{
uint32_t hash_data_offset = GetHashDataOffset (hash_idx);
lldb::offset_t hash_data_offset = GetHashDataOffset (hash_idx);
while (hash_data_offset != UINT32_MAX)
{
const uint32_t prev_hash_data_offset = hash_data_offset;
const lldb::offset_t prev_hash_data_offset = hash_data_offset;
Result hash_result = GetHashDataForName (name, &hash_data_offset, pair);
// Check the result of getting our hash data
switch (hash_result)
@ -505,7 +505,7 @@ public:
virtual Result
GetHashDataForName (const char *name,
uint32_t* hash_data_offset_ptr,
lldb::offset_t* hash_data_offset_ptr,
Pair &pair) const = 0;
const HeaderType &

30
lldb/include/lldb/Core/Module.h
View File

@ -247,7 +247,7 @@ public:
/// @return
/// The number of matches added to \a sc_list.
//------------------------------------------------------------------
uint32_t
size_t
FindCompileUnits (const FileSpec &path,
bool append,
SymbolContextList &sc_list);
@ -284,7 +284,7 @@ public:
/// @return
/// The number of matches added to \a sc_list.
//------------------------------------------------------------------
uint32_t
size_t
FindFunctions (const ConstString &name,
const ClangNamespaceDecl *namespace_decl,
uint32_t name_type_mask,
@ -315,7 +315,7 @@ public:
/// @return
/// The number of matches added to \a sc_list.
//------------------------------------------------------------------
uint32_t
size_t
FindFunctions (const RegularExpression& regex,
bool symbols_ok,
bool inlines_ok,
@ -348,11 +348,11 @@ public:
/// @return
/// The number of matches added to \a variable_list.
//------------------------------------------------------------------
uint32_t
size_t
FindGlobalVariables (const ConstString &name,
const ClangNamespaceDecl *namespace_decl,
bool append,
uint32_t max_matches,
size_t max_matches,
VariableList& variable_list);
//------------------------------------------------------------------
@ -377,10 +377,10 @@ public:
/// @return
/// The number of matches added to \a variable_list.
//------------------------------------------------------------------
uint32_t
size_t
FindGlobalVariables (const RegularExpression& regex,
bool append,
uint32_t max_matches,
size_t max_matches,
VariableList& variable_list);
//------------------------------------------------------------------
@ -424,11 +424,11 @@ public:
/// @return
/// The number of matches added to \a type_list.
//------------------------------------------------------------------
uint32_t
size_t
FindTypes (const SymbolContext& sc,
const ConstString &type_name,
bool exact_match,
uint32_t max_matches,
size_t max_matches,
TypeList& types);
lldb::TypeSP
@ -458,11 +458,11 @@ public:
/// @return
/// The number of matches added to \a type_list.
//------------------------------------------------------------------
uint32_t
size_t
FindTypesInNamespace (const SymbolContext& sc,
const ConstString &type_name,
const ClangNamespaceDecl *namespace_decl,
uint32_t max_matches,
size_t max_matches,
TypeList& type_list);
//------------------------------------------------------------------
@ -570,11 +570,11 @@ public:
/// The number of compile units that the symbol vendor plug-in
/// finds.
//------------------------------------------------------------------
uint32_t
size_t
GetNumCompileUnits();
lldb::CompUnitSP
GetCompileUnitAtIndex (uint32_t);
GetCompileUnitAtIndex (size_t idx);
const ConstString &
GetObjectName() const;
@ -963,12 +963,12 @@ protected:
private:
uint32_t
size_t
FindTypes_Impl (const SymbolContext& sc,
const ConstString &name,
const ClangNamespaceDecl *namespace_decl,
bool append,
uint32_t max_matches,
size_t max_matches,
TypeList& types);

28
lldb/include/lldb/Core/ModuleList.h
View File

@ -165,7 +165,7 @@ public:
return m_modules_mutex;
}
uint32_t
size_t
GetIndexForModule (const Module *module) const;
//------------------------------------------------------------------
@ -181,7 +181,7 @@ public:
/// @see ModuleList::GetSize()
//------------------------------------------------------------------
lldb::ModuleSP
GetModuleAtIndex (uint32_t idx) const;
GetModuleAtIndex (size_t idx) const;
//------------------------------------------------------------------
/// Get the module shared pointer for the module at index \a idx without
@ -198,7 +198,7 @@ public:
/// @see ModuleList::GetSize()
//------------------------------------------------------------------
lldb::ModuleSP
GetModuleAtIndexUnlocked (uint32_t idx) const;
GetModuleAtIndexUnlocked (size_t idx) const;
//------------------------------------------------------------------
/// Get the module pointer for the module at index \a idx.
@ -213,7 +213,7 @@ public:
/// @see ModuleList::GetSize()
//------------------------------------------------------------------
Module*
GetModulePointerAtIndex (uint32_t idx) const;
GetModulePointerAtIndex (size_t idx) const;
//------------------------------------------------------------------
/// Get the module pointer for the module at index \a idx without
@ -230,7 +230,7 @@ public:
/// @see ModuleList::GetSize()
//------------------------------------------------------------------
Module*
GetModulePointerAtIndexUnlocked (uint32_t idx) const;
GetModulePointerAtIndexUnlocked (size_t idx) const;
//------------------------------------------------------------------
/// Find compile units by partial or full path.
@ -253,7 +253,7 @@ public:
/// @return
/// The number of matches added to \a sc_list.
//------------------------------------------------------------------
uint32_t
size_t
FindCompileUnits (const FileSpec &path,
bool append,
SymbolContextList &sc_list) const;
@ -261,7 +261,7 @@ public:
//------------------------------------------------------------------
/// @see Module::FindFunctions ()
//------------------------------------------------------------------
uint32_t
size_t
FindFunctions (const ConstString &name,
uint32_t name_type_mask,
bool include_symbols,
@ -292,10 +292,10 @@ public:
/// @return
/// The number of matches added to \a variable_list.
//------------------------------------------------------------------
uint32_t
size_t
FindGlobalVariables (const ConstString &name,
bool append,
uint32_t max_matches,
size_t max_matches,
VariableList& variable_list) const;
//------------------------------------------------------------------
@ -320,10 +320,10 @@ public:
/// @return
/// The number of matches added to \a variable_list.
//------------------------------------------------------------------
uint32_t
size_t
FindGlobalVariables (const RegularExpression& regex,
bool append,
uint32_t max_matches,
size_t max_matches,
VariableList& variable_list) const;
//------------------------------------------------------------------
@ -422,11 +422,11 @@ public:
/// @return
/// The number of matches added to \a type_list.
//------------------------------------------------------------------
uint32_t
size_t
FindTypes (const SymbolContext& sc,
const ConstString &name,
bool name_is_fully_qualified,
uint32_t max_matches,
size_t max_matches,
TypeList& types) const;
bool
@ -503,7 +503,7 @@ public:
FindSharedModules (const ModuleSpec &module_spec,
ModuleList &matching_module_list);
static uint32_t
static size_t
RemoveOrphanSharedModules (bool mandatory);
static bool

2
lldb/include/lldb/Core/PluginManager.h
View File

@ -216,7 +216,7 @@ public:
static const char *
GetPlatformPluginDescriptionAtIndex (uint32_t idx);
static uint32_t
static size_t
AutoCompletePlatformName (const char *partial_name,
StringList &matches);
//------------------------------------------------------------------

2
lldb/include/lldb/Core/RegisterValue.h
View File

@ -345,7 +345,7 @@ namespace lldb_private {
Error
SetValueFromData (const RegisterInfo *reg_info,
DataExtractor &data,
uint32_t offset,
lldb::offset_t offset,
bool partial_data_ok);
// The default value of 0 for reg_name_right_align_at means no alignment at all.

16
lldb/include/lldb/Core/Scalar.h
View File

@ -73,9 +73,9 @@ public:
bool
GetData (DataExtractor &data, size_t limit_byte_size = UINT32_MAX) const;
uint32_t
size_t
GetAsMemoryData (void *dst,
uint32_t dst_len,
size_t dst_len,
lldb::ByteOrder dst_byte_order,
Error &error) const;
@ -219,7 +219,7 @@ public:
GetRawBits64 (uint64_t fail_value) const;
Error
SetValueFromCString (const char *s, lldb::Encoding encoding, uint32_t byte_size);
SetValueFromCString (const char *s, lldb::Encoding encoding, size_t byte_size);
static bool
UIntValueIsValidForSize (uint64_t uval64, size_t total_byte_size)
@ -249,6 +249,16 @@ public:
}
protected:
typedef int sint_t;
typedef unsigned int uint_t;
typedef long slong_t;
typedef unsigned long ulong_t;
typedef long long slonglong_t;
typedef unsigned long long ulonglong_t;
typedef float float_t;
typedef double double_t;
typedef long double long_double_t;
union ValueData
{
int sint;

10
lldb/include/lldb/Core/Section.h
View File

@ -34,13 +34,13 @@ public:
virtual
~SectionList();
uint32_t
size_t
AddSection (const lldb::SectionSP& section_sp);
uint32_t
size_t
AddUniqueSection (const lldb::SectionSP& section_sp);
uint32_t
size_t
FindSectionIndex (const Section* sect);
bool
@ -56,7 +56,7 @@ public:
FindSectionByID (lldb::user_id_t sect_id) const;
lldb::SectionSP
FindSectionByType (lldb::SectionType sect_type, bool check_children, uint32_t start_idx = 0) const;
FindSectionByType (lldb::SectionType sect_type, bool check_children, size_t start_idx = 0) const;
lldb::SectionSP
FindSectionContainingFileAddress (lldb::addr_t addr, uint32_t depth = UINT32_MAX) const;
@ -82,7 +82,7 @@ public:
ReplaceSection (lldb::user_id_t sect_id, const lldb::SectionSP& section_sp, uint32_t depth = UINT32_MAX);
lldb::SectionSP
GetSectionAtIndex (uint32_t idx) const;
GetSectionAtIndex (size_t idx) const;
size_t
Slide (lldb::addr_t slide_amount, bool slide_children);

64
lldb/include/lldb/Core/Stream.h
View File

@ -87,13 +87,13 @@ public:
/// @return
/// The number of bytes that were appended to the stream.
//------------------------------------------------------------------
virtual int
virtual size_t
Write (const void *src, size_t src_len) = 0;
//------------------------------------------------------------------
// Member functions
//------------------------------------------------------------------
int
size_t
PutChar (char ch);
//------------------------------------------------------------------
@ -125,7 +125,7 @@ public:
/// @return
/// The number of bytes that were appended to the stream.
//------------------------------------------------------------------
int
size_t
PrintfAsRawHex8 (const char *format, ...) __attribute__ ((format (printf, 2, 3)));
//------------------------------------------------------------------
@ -142,59 +142,59 @@ public:
/// @return
/// The number of bytes that were appended to the stream.
//------------------------------------------------------------------
int
size_t
PutHex8 (uint8_t uvalue);
int
size_t
PutNHex8 (size_t n, uint8_t uvalue);
int
size_t
PutHex16 (uint16_t uvalue,
lldb::ByteOrder byte_order = lldb::eByteOrderInvalid);
int
size_t
PutHex32 (uint32_t uvalue,
lldb::ByteOrder byte_order = lldb::eByteOrderInvalid);
int
size_t
PutHex64 (uint64_t uvalue,
lldb::ByteOrder byte_order = lldb::eByteOrderInvalid);
int
size_t
PutMaxHex64 (uint64_t uvalue,
size_t byte_size,
lldb::ByteOrder byte_order = lldb::eByteOrderInvalid);
int
size_t
PutFloat (float f,
lldb::ByteOrder byte_order = lldb::eByteOrderInvalid);
int
size_t
PutDouble (double d,
lldb::ByteOrder byte_order = lldb::eByteOrderInvalid);
int
size_t
PutLongDouble (long double ld,
lldb::ByteOrder byte_order = lldb::eByteOrderInvalid);
int
size_t
PutPointer (void *ptr);
// Append \a src_len bytes from \a src to the stream as hex characters
// (two ascii characters per byte of input data)
int
size_t
PutBytesAsRawHex8 (const void *src,
size_t src_len,
lldb::ByteOrder src_byte_order = lldb::eByteOrderInvalid,
lldb::ByteOrder dst_byte_order = lldb::eByteOrderInvalid);
// Append \a src_len bytes from \a s to the stream as binary data.
int
size_t
PutRawBytes (const void *s,
size_t src_len,
lldb::ByteOrder src_byte_order = lldb::eByteOrderInvalid,
lldb::ByteOrder dst_byte_order = lldb::eByteOrderInvalid);
int
size_t
PutCStringAsRawHex8 (const char *s);
//------------------------------------------------------------------
@ -359,7 +359,7 @@ public:
/// A suffix C string. If NULL, no suffix will be output.
//------------------------------------------------------------------
void
Address (uint64_t addr, int addr_size, const char *prefix = NULL, const char *suffix = NULL);
Address (uint64_t addr, uint32_t addr_size, const char *prefix = NULL, const char *suffix = NULL);
//------------------------------------------------------------------
/// Output an address range to this stream.
@ -383,7 +383,7 @@ public:
/// A suffix C string. If NULL, no suffix will be output.
//------------------------------------------------------------------
void
AddressRange(uint64_t lo_addr, uint64_t hi_addr, int addr_size, const char *prefix = NULL, const char *suffix = NULL);
AddressRange(uint64_t lo_addr, uint64_t hi_addr, uint32_t addr_size, const char *prefix = NULL, const char *suffix = NULL);
//------------------------------------------------------------------
/// Output a C string to the stream.
@ -393,13 +393,13 @@ public:
/// @param[in] cstr
/// The string to be output to the stream.
//------------------------------------------------------------------
int
size_t
PutCString (const char *cstr);
//------------------------------------------------------------------
/// Output and End of Line character to the stream.
//------------------------------------------------------------------
int
size_t
EOL();
//------------------------------------------------------------------
@ -409,7 +409,7 @@ public:
/// The size of an address in bytes that is used when outputting
/// address and pointer values to the stream.
//------------------------------------------------------------------
uint8_t
uint32_t
GetAddressByteSize () const;
//------------------------------------------------------------------
@ -478,7 +478,7 @@ public:
/// A C string to print following the indentation. If NULL, just
/// output the indentation characters.
//------------------------------------------------------------------
int
size_t
Indent(const char *s = NULL);
//------------------------------------------------------------------
@ -520,10 +520,10 @@ public:
/// Variable arguments that are needed for the printf style
/// format string \a format.
//------------------------------------------------------------------
int
size_t
Printf (const char *format, ...) __attribute__ ((format (printf, 2, 3)));
int
size_t
PrintfVarArg(const char *format, va_list args);
//------------------------------------------------------------------
@ -549,7 +549,7 @@ public:
/// address and pointer values.
//------------------------------------------------------------------
void
SetAddressByteSize (uint8_t addr_size);
SetAddressByteSize (uint32_t addr_size);
//------------------------------------------------------------------
/// Set the current indentation level.
@ -572,7 +572,7 @@ public:
/// @param[in] format
/// The optional printf format that can be overridden.
//------------------------------------------------------------------
int
size_t
PutSLEB128 (int64_t uval);
//------------------------------------------------------------------
@ -587,7 +587,7 @@ public:
/// @param[in] format
/// The optional printf format that can be overridden.
//------------------------------------------------------------------
int
size_t
PutULEB128 (uint64_t uval);
static void
@ -597,12 +597,12 @@ protected:
//------------------------------------------------------------------
// Member variables
//------------------------------------------------------------------
Flags m_flags; ///< Dump flags.
uint8_t m_addr_size; ///< Size of an address in bytes.
lldb::ByteOrder m_byte_order;///< Byte order to use when encoding scalar types.
int m_indent_level; ///< Indention level.
Flags m_flags; ///< Dump flags.
uint32_t m_addr_size; ///< Size of an address in bytes.
lldb::ByteOrder m_byte_order; ///< Byte order to use when encoding scalar types.
int m_indent_level; ///< Indention level.
int _PutHex8 (uint8_t uvalue, bool add_prefix);
size_t _PutHex8 (uint8_t uvalue, bool add_prefix);
};
} // namespace lldb_private

2
lldb/include/lldb/Core/StreamAsynchronousIO.h
View File

@ -28,7 +28,7 @@ public:
virtual void
Flush ();
virtual int
virtual size_t
Write (const void *src, size_t src_len);

2
lldb/include/lldb/Core/StreamBuffer.h
View File

@ -47,7 +47,7 @@ public:
// Nothing to do when flushing a buffer based stream...
}
virtual int
virtual size_t
Write (const void *s, size_t length)
{
if (s && length)

2
lldb/include/lldb/Core/StreamCallback.h
View File

@ -29,7 +29,7 @@ public:
virtual void
Flush ();
virtual int
virtual size_t
Write (const void *src, size_t src_len);

2
lldb/include/lldb/Core/StreamFile.h
View File

@ -57,7 +57,7 @@ public:
virtual void
Flush ();
virtual int
virtual size_t
Write (const void *s, size_t length);
protected:

2
lldb/include/lldb/Core/StreamString.h
View File

@ -31,7 +31,7 @@ public:
virtual void
Flush ();
virtual int
virtual size_t
Write (const void *s, size_t length);
void

8
lldb/include/lldb/Core/StreamTee.h
View File

@ -93,14 +93,14 @@ public:
}
}
virtual int
virtual size_t
Write (const void *s, size_t length)
{
Mutex::Locker locker (m_streams_mutex);
if (m_streams.empty())
return 0;
int min_bytes_written = INT_MAX;
size_t min_bytes_written = SIZE_MAX;
collection::iterator pos, end;
for (pos = m_streams.begin(), end = m_streams.end(); pos != end; ++pos)
{
@ -111,11 +111,13 @@ public:
Stream *strm = pos->get();
if (strm)
{
int bytes_written = strm->Write (s, length);
const size_t bytes_written = strm->Write (s, length);
if (min_bytes_written > bytes_written)
min_bytes_written = bytes_written;
}
}
if (min_bytes_written == SIZE_MAX)
return 0;
return min_bytes_written;
}

2
lldb/include/lldb/Core/StringList.h
View File

@ -48,7 +48,7 @@ public:
bool
ReadFileLines (FileSpec &input_file);
uint32_t
size_t
GetSize () const;
const char *

2
lldb/include/lldb/Core/VMRange.h
View File

@ -161,7 +161,7 @@ public:
// Returns a valid index into coll when a match is found, else UINT32_MAX
// is returned
static uint32_t
static size_t
FindRangeIndexThatContainsValue (const VMRange::collection& coll, lldb::addr_t value);
protected:

2
lldb/include/lldb/Core/Value.h
View File

@ -213,7 +213,7 @@ public:
}
void
ResizeData(int len);
ResizeData(size_t len);
bool
ValueOf(ExecutionContext *exe_ctx, clang::ASTContext *ast_context);

54
lldb/include/lldb/Core/ValueObject.h
View File

@ -732,32 +732,32 @@ public:
GetName() const;
virtual lldb::ValueObjectSP
GetChildAtIndex (uint32_t idx, bool can_create);
GetChildAtIndex (size_t idx, bool can_create);
// this will always create the children if necessary
lldb::ValueObjectSP
GetChildAtIndexPath (const std::initializer_list<uint32_t> &idxs,
uint32_t* index_of_error = NULL);
GetChildAtIndexPath (const std::initializer_list<size_t> &idxs,
size_t* index_of_error = NULL);
lldb::ValueObjectSP
GetChildAtIndexPath (const std::vector<uint32_t> &idxs,
uint32_t* index_of_error = NULL);
GetChildAtIndexPath (const std::vector<size_t> &idxs,
size_t* index_of_error = NULL);
lldb::ValueObjectSP
GetChildAtIndexPath (const std::initializer_list< std::pair<uint32_t, bool> > &idxs,
uint32_t* index_of_error = NULL);
GetChildAtIndexPath (const std::initializer_list< std::pair<size_t, bool> > &idxs,
size_t* index_of_error = NULL);
lldb::ValueObjectSP
GetChildAtIndexPath (const std::vector< std::pair<uint32_t, bool> > &idxs,
uint32_t* index_of_error = NULL);
GetChildAtIndexPath (const std::vector< std::pair<size_t, bool> > &idxs,
size_t* index_of_error = NULL);
virtual lldb::ValueObjectSP
GetChildMemberWithName (const ConstString &name, bool can_create);
virtual uint32_t
virtual size_t
GetIndexOfChildWithName (const ConstString &name);
uint32_t
size_t
GetNumChildren ();
const Value &
@ -833,13 +833,13 @@ public:
GetSyntheticChild (const ConstString &key) const;
lldb::ValueObjectSP
GetSyntheticArrayMember (int32_t index, bool can_create);
GetSyntheticArrayMember (size_t index, bool can_create);
lldb::ValueObjectSP
GetSyntheticArrayMemberFromPointer (int32_t index, bool can_create);
GetSyntheticArrayMemberFromPointer (size_t index, bool can_create);
lldb::ValueObjectSP
GetSyntheticArrayMemberFromArray (int32_t index, bool can_create);
GetSyntheticArrayMemberFromArray (size_t index, bool can_create);
lldb::ValueObjectSP
GetSyntheticBitFieldChild (uint32_t from, uint32_t to, bool can_create);
@ -1117,13 +1117,13 @@ protected:
{
public:
ChildrenManager() :
m_mutex(Mutex::eMutexTypeRecursive),
m_children(),
m_children_count(0)
m_mutex(Mutex::eMutexTypeRecursive),
m_children(),
m_children_count(0)
{}
bool
HasChildAtIndex (uint32_t idx)
HasChildAtIndex (size_t idx)
{
Mutex::Locker locker(m_mutex);
ChildrenIterator iter = m_children.find(idx);
@ -1132,7 +1132,7 @@ protected:
}
ValueObject*
GetChildAtIndex (uint32_t idx)
GetChildAtIndex (size_t idx)
{
Mutex::Locker locker(m_mutex);
ChildrenIterator iter = m_children.find(idx);
@ -1144,7 +1144,7 @@ protected:
}
void
SetChildAtIndex (uint32_t idx, ValueObject* valobj)
SetChildAtIndex (size_t idx, ValueObject* valobj)
{
ChildrenPair pair(idx,valobj); // we do not need to be mutex-protected to make a pair
Mutex::Locker locker(m_mutex);
@ -1152,12 +1152,12 @@ protected:
}
void
SetChildrenCount (uint32_t count)
SetChildrenCount (size_t count)
{
m_children_count = count;
}
uint32_t
size_t
GetChildrenCount ()
{
return m_children_count;
@ -1172,12 +1172,12 @@ protected:
}
private:
typedef std::map<uint32_t, ValueObject*> ChildrenMap;
typedef std::map<size_t, ValueObject*> ChildrenMap;
typedef ChildrenMap::iterator ChildrenIterator;
typedef ChildrenMap::value_type ChildrenPair;
Mutex m_mutex;
ChildrenMap m_children;
uint32_t m_children_count;
size_t m_children_count;
};
//------------------------------------------------------------------
@ -1279,14 +1279,14 @@ protected:
// Should only be called by ValueObject::GetChildAtIndex()
// Returns a ValueObject managed by this ValueObject's manager.
virtual ValueObject *
CreateChildAtIndex (uint32_t idx, bool synthetic_array_member, int32_t synthetic_index);
CreateChildAtIndex (size_t idx, bool synthetic_array_member, int32_t synthetic_index);
// Should only be called by ValueObject::GetNumChildren()
virtual uint32_t
virtual size_t
CalculateNumChildren() = 0;
void
SetNumChildren (uint32_t num_children);
SetNumChildren (size_t num_children);
void
SetValueDidChange (bool value_changed);

2
lldb/include/lldb/Core/ValueObjectCast.h
View File

@ -35,7 +35,7 @@ public:
virtual size_t
GetByteSize();
virtual uint32_t
virtual size_t
CalculateNumChildren();
virtual lldb::ValueType

2
lldb/include/lldb/Core/ValueObjectChild.h
View File

@ -53,7 +53,7 @@ public:
virtual lldb::ValueType
GetValueType() const;
virtual uint32_t
virtual size_t
CalculateNumChildren();
virtual ConstString

14
lldb/include/lldb/Core/ValueObjectConstResult.h
View File

@ -47,7 +47,7 @@ public:
const ConstString &name,
const lldb::DataBufferSP &result_data_sp,
lldb::ByteOrder byte_order,
uint8_t addr_size,
uint32_t addr_size,
lldb::addr_t address = LLDB_INVALID_ADDRESS);
static lldb::ValueObjectSP
@ -57,7 +57,7 @@ public:
const ConstString &name,
lldb::addr_t address,
AddressType address_type,
uint8_t addr_byte_size);
uint32_t addr_byte_size);
static lldb::ValueObjectSP
Create (ExecutionContextScope *exe_scope,
@ -78,7 +78,7 @@ public:
virtual lldb::ValueType
GetValueType() const;
virtual uint32_t
virtual size_t
CalculateNumChildren();
virtual ConstString
@ -101,7 +101,7 @@ public:
Dereference (Error &error);
virtual ValueObject *
CreateChildAtIndex (uint32_t idx, bool synthetic_array_member, int32_t synthetic_index);
CreateChildAtIndex (size_t idx, bool synthetic_array_member, int32_t synthetic_index);
virtual lldb::ValueObjectSP
GetSyntheticChildAtOffset(uint32_t offset, const ClangASTType& type, bool can_create);
@ -147,7 +147,7 @@ protected:
clang::ASTContext *m_clang_ast; // The clang AST that the clang type comes from
ConstString m_type_name;
uint32_t m_byte_size;
size_t m_byte_size;
ValueObjectConstResultImpl m_impl;
@ -171,7 +171,7 @@ private:
const ConstString &name,
const lldb::DataBufferSP &result_data_sp,
lldb::ByteOrder byte_order,
uint8_t addr_size,
uint32_t addr_size,
lldb::addr_t address);
ValueObjectConstResult (ExecutionContextScope *exe_scope,
@ -180,7 +180,7 @@ private:
const ConstString &name,
lldb::addr_t address,
AddressType address_type,
uint8_t addr_byte_size);
uint32_t addr_byte_size);
ValueObjectConstResult (ExecutionContextScope *exe_scope,
clang::ASTContext *clang_ast,

2
lldb/include/lldb/Core/ValueObjectConstResultChild.h
View File

@ -43,7 +43,7 @@ public:
Dereference (Error &error);
virtual ValueObject *
CreateChildAtIndex (uint32_t idx, bool synthetic_array_member, int32_t synthetic_index);
CreateChildAtIndex (size_t idx, bool synthetic_array_member, int32_t synthetic_index);
virtual lldb::clang_type_t
GetClangType ()

2
lldb/include/lldb/Core/ValueObjectConstResultImpl.h
View File

@ -39,7 +39,7 @@ public:
Dereference (Error &error);
ValueObject *
CreateChildAtIndex (uint32_t idx, bool synthetic_array_member, int32_t synthetic_index);
CreateChildAtIndex (size_t idx, bool synthetic_array_member, int32_t synthetic_index);
lldb::ValueObjectSP
GetSyntheticChildAtOffset (uint32_t offset, const ClangASTType& type, bool can_create);

2
lldb/include/lldb/Core/ValueObjectDynamicValue.h
View File

@ -38,7 +38,7 @@ public:
virtual ConstString
GetQualifiedTypeName();
virtual uint32_t
virtual size_t
CalculateNumChildren();
virtual lldb::ValueType

10
lldb/include/lldb/Core/ValueObjectList.h
View File

@ -50,20 +50,20 @@ public:
lldb::ValueObjectSP
FindValueObjectByPointer (ValueObject *valobj);
uint32_t
size_t
GetSize () const;
void
Resize (uint32_t size);
Resize (size_t size);
lldb::ValueObjectSP
GetValueObjectAtIndex (uint32_t idx);
GetValueObjectAtIndex (size_t idx);
lldb::ValueObjectSP
RemoveValueObjectAtIndex (uint32_t idx);
RemoveValueObjectAtIndex (size_t idx);
void
SetValueObjectAtIndex (uint32_t idx,
SetValueObjectAtIndex (size_t idx,
const lldb::ValueObjectSP &valobj_sp);
lldb::ValueObjectSP

2
lldb/include/lldb/Core/ValueObjectMemory.h
View File

@ -47,7 +47,7 @@ public:
virtual ConstString
GetTypeName();
virtual uint32_t
virtual size_t
CalculateNumChildren();
virtual lldb::ValueType

12
lldb/include/lldb/Core/ValueObjectRegister.h
View File

@ -46,11 +46,11 @@ public:
virtual ConstString
GetQualifiedTypeName();
virtual uint32_t
virtual size_t
CalculateNumChildren();
virtual ValueObject *
CreateChildAtIndex (uint32_t idx, bool synthetic_array_member, int32_t synthetic_index);
CreateChildAtIndex (size_t idx, bool synthetic_array_member, int32_t synthetic_index);
protected:
virtual bool
@ -96,16 +96,16 @@ public:
virtual ConstString
GetQualifiedTypeName();
virtual uint32_t
virtual size_t
CalculateNumChildren();
virtual ValueObject *
CreateChildAtIndex (uint32_t idx, bool synthetic_array_member, int32_t synthetic_index);
CreateChildAtIndex (size_t idx, bool synthetic_array_member, int32_t synthetic_index);
virtual lldb::ValueObjectSP
GetChildMemberWithName (const ConstString &name, bool can_create);
virtual uint32_t
virtual size_t
GetIndexOfChildWithName (const ConstString &name);
@ -154,7 +154,7 @@ public:
virtual ConstString
GetTypeName();
virtual uint32_t
virtual size_t
CalculateNumChildren();
virtual bool

6
lldb/include/lldb/Core/ValueObjectSyntheticFilter.h
View File

@ -42,19 +42,19 @@ public:
virtual bool
MightHaveChildren();
virtual uint32_t
virtual size_t
CalculateNumChildren();
virtual lldb::ValueType
GetValueType() const;
virtual lldb::ValueObjectSP
GetChildAtIndex (uint32_t idx, bool can_create);
GetChildAtIndex (size_t idx, bool can_create);
virtual lldb::ValueObjectSP
GetChildMemberWithName (const ConstString &name, bool can_create);
virtual uint32_t
virtual size_t
GetIndexOfChildWithName (const ConstString &name);
virtual bool

2
lldb/include/lldb/Core/ValueObjectVariable.h
View File

@ -40,7 +40,7 @@ public:
virtual ConstString
GetQualifiedTypeName();
virtual uint32_t
virtual size_t
CalculateNumChildren();
virtual lldb::ValueType

1
lldb/include/lldb/Core/dwarf.h
View File

@ -34,7 +34,6 @@ typedef uint32_t dw_offset_t; // Dwarf Debug Information Entry offset for
#endif
/* Constants */
#define DW_INVALID_ADDRESS (~(dw_addr_t)0)
#define DW_INVALID_OFFSET (~(dw_offset_t)0)
#define DW_INVALID_INDEX 0xFFFFFFFFul

10
lldb/include/lldb/Expression/ClangFunction.h
View File

@ -132,7 +132,8 @@ public:
/// @return
/// The number of errors.
//------------------------------------------------------------------
unsigned CompileFunction (Stream &errors);
unsigned
CompileFunction (Stream &errors);
//------------------------------------------------------------------
/// Insert the default function wrapper and its default argument struct
@ -152,9 +153,10 @@ public:
/// @return
/// True on success; false otherwise.
//------------------------------------------------------------------
bool InsertFunction (ExecutionContext &exe_ctx,
lldb::addr_t &args_addr_ref,
Stream &errors);
bool
InsertFunction (ExecutionContext &exe_ctx,
lldb::addr_t &args_addr_ref,
Stream &errors);
//------------------------------------------------------------------
/// Insert the default function wrapper (using the JIT)

22
lldb/include/lldb/Expression/DWARFExpression.h
View File

@ -59,8 +59,8 @@ public:
/// The byte length of the location expression.
//------------------------------------------------------------------
DWARFExpression(const DataExtractor& data,
uint32_t data_offset,
uint32_t data_length);
lldb::offset_t data_offset,
lldb::offset_t data_length);
//------------------------------------------------------------------
/// Copy constructor
@ -184,7 +184,7 @@ public:
/// The byte length of the location expression.
//------------------------------------------------------------------
void
SetOpcodeData(const DataExtractor& data, uint32_t data_offset, uint32_t data_length);
SetOpcodeData(const DataExtractor& data, lldb::offset_t data_offset, lldb::offset_t data_length);
//------------------------------------------------------------------
/// Copy the DWARF location expression into a local buffer.
@ -212,8 +212,8 @@ public:
//------------------------------------------------------------------
void
CopyOpcodeData (const DataExtractor& data,
uint32_t data_offset,
uint32_t data_length);
lldb::offset_t data_offset,
lldb::offset_t data_length);
//------------------------------------------------------------------
@ -340,8 +340,8 @@ public:
ClangExpressionDeclMap *decl_map,
RegisterContext *reg_ctx,
const DataExtractor& opcodes,
const uint32_t offset,
const uint32_t length,
const lldb::offset_t offset,
const lldb::offset_t length,
const uint32_t reg_set,
const Value* initial_value_ptr,
Value& result,
@ -403,16 +403,16 @@ protected:
//------------------------------------------------------------------
void
DumpLocation(Stream *s,
uint32_t offset,
uint32_t length,
lldb::offset_t offset,
lldb::offset_t length,
lldb::DescriptionLevel level,
ABI *abi) const;
bool
GetLocation (lldb::addr_t base_addr,
lldb::addr_t pc,
uint32_t &offset,
uint32_t &len);
lldb::offset_t &offset,
lldb::offset_t &len);
//------------------------------------------------------------------
/// Classes that inherit from DWARFExpression can see and modify these

4
lldb/include/lldb/Host/File.h
View File

@ -457,10 +457,10 @@ public:
/// Variable arguments that are needed for the printf style
/// format string \a format.
//------------------------------------------------------------------
int
size_t
Printf (const char *format, ...) __attribute__ ((format (printf, 2, 3)));
int
size_t
PrintfVarArg(const char *format, va_list args);
protected:

6
lldb/include/lldb/Interpreter/Args.h
View File

@ -268,7 +268,7 @@ public:
// FIXME: Handle the quote character somehow.
//------------------------------------------------------------------
void
SetArguments (int argc, const char **argv);
SetArguments (size_t argc, const char **argv);
void
SetArguments (const char **argv);
@ -390,7 +390,7 @@ public:
static bool
StringToBoolean (const char *s, bool fail_value, bool *success_ptr);
static int32_t
static int64_t
StringToOptionEnum (const char *s, OptionEnumValueElement *enum_values, int32_t fail_value, Error &error);
static lldb::ScriptLanguage
@ -399,7 +399,7 @@ public:
static Error
StringToFormat (const char *s,
lldb::Format &format,
uint32_t *byte_size_ptr); // If non-NULL, then a byte size can precede the format character
size_t *byte_size_ptr); // If non-NULL, then a byte size can precede the format character
static lldb::Encoding
StringToEncoding (const char *s,

2
lldb/include/lldb/Interpreter/CommandInterpreter.h
View File

@ -278,7 +278,7 @@ public:
const char *command_word,
const char *separator,
const char *help_text,
uint32_t max_word_len);
size_t max_word_len);
// this mimics OutputFormattedHelpText but it does perform a much simpler
// formatting, basically ensuring line alignment. This is only good if you have

2
lldb/include/lldb/Interpreter/CommandObject.h
View File

@ -409,7 +409,7 @@ public:
/// total number of matches, and the window the user wants returned.
///
/// @return
/// \btrue if we were in an option, \bfalse otherwise.
/// The number of completions.
//------------------------------------------------------------------
virtual int

4
lldb/include/lldb/Interpreter/CommandReturnObject.h
View File

@ -124,7 +124,7 @@ public:
AppendMessageWithFormat (const char *format, ...) __attribute__ ((format (printf, 2, 3)));
void
AppendRawWarning (const char *in_string, int len = -1);
AppendRawWarning (const char *in_string);
void
AppendWarning (const char *in_string);
@ -136,7 +136,7 @@ public:
AppendError (const char *in_string);
void
AppendRawError (const char *in_string, int len = -1);
AppendRawError (const char *in_string);
void
AppendErrorWithFormat (const char *format, ...) __attribute__ ((format (printf, 2, 3)));

12
lldb/include/lldb/Interpreter/OptionValueArray.h
View File

@ -79,14 +79,14 @@ public:
// Subclass specific functions
//---------------------------------------------------------------------
uint32_t
size_t
GetSize () const
{
return m_values.size();
}
lldb::OptionValueSP
operator[](uint32_t idx) const
operator[](size_t idx) const
{
lldb::OptionValueSP value_sp;
if (idx < m_values.size())
@ -95,7 +95,7 @@ public:
}
lldb::OptionValueSP
GetValueAtIndex (uint32_t idx) const
GetValueAtIndex (size_t idx) const
{
lldb::OptionValueSP value_sp;
if (idx < m_values.size())
@ -117,7 +117,7 @@ public:
}
bool
InsertValue (uint32_t idx, const lldb::OptionValueSP &value_sp)
InsertValue (size_t idx, const lldb::OptionValueSP &value_sp)
{
// Make sure the value_sp object is allowed to contain
// values of the type passed in...
@ -133,7 +133,7 @@ public:
}
bool
ReplaceValue (uint32_t idx, const lldb::OptionValueSP &value_sp)
ReplaceValue (size_t idx, const lldb::OptionValueSP &value_sp)
{
// Make sure the value_sp object is allowed to contain
// values of the type passed in...
@ -149,7 +149,7 @@ public:
}
bool
DeleteValue (uint32_t idx)
DeleteValue (size_t idx)
{
if (idx < m_values.size())
{

2
lldb/include/lldb/Interpreter/OptionValueDictionary.h
View File

@ -80,7 +80,7 @@ public:
// Subclass specific functions
//---------------------------------------------------------------------
uint32_t
size_t
GetNumValues() const
{
return m_values.size();

2
lldb/include/lldb/Interpreter/ScriptInterpreter.h
View File

@ -340,7 +340,7 @@ public:
return false;
}
virtual uint32_t
virtual size_t
CalculateNumChildren (const lldb::ScriptInterpreterObjectSP& implementor)
{
return 0;

2
lldb/include/lldb/Interpreter/ScriptInterpreterPython.h
View File

@ -98,7 +98,7 @@ public:
lldb::tid_t tid,
lldb::addr_t context);
virtual uint32_t
virtual size_t
CalculateNumChildren (const lldb::ScriptInterpreterObjectSP& implementor);
virtual lldb::ValueObjectSP

2
lldb/include/lldb/Symbol/Block.h
View File

@ -435,7 +435,7 @@ public:
Block *
FindBlockByID (lldb::user_id_t block_id);
uint32_t
size_t
GetNumRanges () const
{
return m_ranges.GetSize();

10
lldb/include/lldb/Symbol/ClangASTContext.h
View File

@ -596,19 +596,19 @@ public:
static lldb::clang_type_t
GetDirectBaseClassAtIndex (clang::ASTContext *ast,
lldb::clang_type_t clang_type,
uint32_t idx,
size_t idx,
uint32_t *bit_offset_ptr);
static lldb::clang_type_t
GetVirtualBaseClassAtIndex (clang::ASTContext *ast,
lldb::clang_type_t clang_type,
uint32_t idx,
size_t idx,
uint32_t *bit_offset_ptr);
static lldb::clang_type_t
GetFieldAtIndex (clang::ASTContext *ast,
lldb::clang_type_t clang_type,
uint32_t idx,
size_t idx,
std::string& name,
uint64_t *bit_offset_ptr,
uint32_t *bitfield_bit_size_ptr,
@ -621,7 +621,7 @@ public:
GetChildClangTypeAtIndex (ExecutionContext *exe_ctx,
const char *parent_name,
lldb::clang_type_t parent_clang_type,
uint32_t idx,
size_t idx,
bool transparent_pointers,
bool omit_empty_base_classes,
bool ignore_array_bounds,
@ -638,7 +638,7 @@ public:
clang::ASTContext *ast,
const char *parent_name,
lldb::clang_type_t parent_clang_type,
uint32_t idx,
size_t idx,
bool transparent_pointers,
bool omit_empty_base_classes,
bool ignore_array_bounds,

2
lldb/include/lldb/Symbol/ObjectFile.h
View File

@ -214,7 +214,7 @@ public:
/// architecture (and object for archives). Returns zero if no
/// architecture or object has been selected.
//------------------------------------------------------------------
virtual size_t
virtual uint32_t
GetAddressByteSize () const = 0;
//------------------------------------------------------------------

4
lldb/include/lldb/Symbol/Symbol.h
View File

@ -37,7 +37,7 @@ public:
bool is_artificial,
const lldb::SectionSP &section_sp,
lldb::addr_t value,
uint32_t size,
lldb::addr_t size,
uint32_t flags);
Symbol (uint32_t symID,
@ -209,7 +209,7 @@ public:
GetByteSize () const;
void
SetByteSize (uint32_t size)
SetByteSize (lldb::addr_t size)
{
m_calculated_size = size > 0;
m_addr_range.SetByteSize(size);

4
lldb/include/lldb/Symbol/SymbolContext.h
View File

@ -459,10 +459,10 @@ public:
/// otherwise.
//------------------------------------------------------------------
bool
GetContextAtIndex(uint32_t idx, SymbolContext& sc) const;
GetContextAtIndex(size_t idx, SymbolContext& sc) const;
bool
RemoveContextAtIndex (uint32_t idx);
RemoveContextAtIndex (size_t idx);
//------------------------------------------------------------------
/// Get accessor for a symbol context list size.
///

22
lldb/include/lldb/Symbol/SymbolVendor.h
View File

@ -100,20 +100,20 @@ public:
uint32_t resolve_scope,
SymbolContextList& sc_list);
virtual uint32_t
virtual size_t
FindGlobalVariables (const ConstString &name,
const ClangNamespaceDecl *namespace_decl,
bool append,
uint32_t max_matches,
size_t max_matches,
VariableList& variables);
virtual uint32_t
virtual size_t
FindGlobalVariables (const RegularExpression& regex,
bool append,
uint32_t max_matches,
size_t max_matches,
VariableList& variables);
virtual uint32_t
virtual size_t
FindFunctions (const ConstString &name,
const ClangNamespaceDecl *namespace_decl,
uint32_t name_type_mask,
@ -121,18 +121,18 @@ public:
bool append,
SymbolContextList& sc_list);
virtual uint32_t
virtual size_t
FindFunctions (const RegularExpression& regex,
bool include_inlines,
bool append,
SymbolContextList& sc_list);
virtual uint32_t
virtual size_t
FindTypes (const SymbolContext& sc,
const ConstString &name,
const ClangNamespaceDecl *namespace_decl,
bool append,
uint32_t max_matches,
size_t max_matches,
TypeList& types);
virtual lldb_private::ClangNamespaceDecl
@ -140,15 +140,15 @@ public:
const ConstString &name,
const ClangNamespaceDecl *parent_namespace_decl);
virtual uint32_t
virtual size_t
GetNumCompileUnits();
virtual bool
SetCompileUnitAtIndex (uint32_t cu_idx,
SetCompileUnitAtIndex (size_t cu_idx,
const lldb::CompUnitSP &cu_sp);
virtual lldb::CompUnitSP
GetCompileUnitAtIndex(uint32_t idx);
GetCompileUnitAtIndex(size_t idx);
TypeList&
GetTypeList()

10
lldb/include/lldb/Symbol/Symtab.h
View File

@ -41,8 +41,8 @@ public:
Symtab(ObjectFile *objfile);
~Symtab();
void Reserve (uint32_t count);
Symbol * Resize (uint32_t count);
void Reserve (size_t count);
Symbol * Resize (size_t count);
uint32_t AddSymbol(const Symbol& symbol);
size_t GetNumSymbols() const;
void Dump(Stream *s, Target *target, SortOrder sort_type);
@ -53,8 +53,8 @@ public:
return m_mutex;
}
Symbol * FindSymbolByID (lldb::user_id_t uid) const;
Symbol * SymbolAtIndex (uint32_t idx);
const Symbol * SymbolAtIndex (uint32_t idx) const;
Symbol * SymbolAtIndex (size_t idx);
const Symbol * SymbolAtIndex (size_t idx) const;
Symbol * FindSymbolWithType (lldb::SymbolType symbol_type, Debug symbol_debug_type, Visibility symbol_visibility, uint32_t &start_idx);
uint32_t AppendSymbolIndexesWithType (lldb::SymbolType symbol_type, std::vector<uint32_t>& indexes, uint32_t start_idx = 0, uint32_t end_index = UINT32_MAX) const;
uint32_t AppendSymbolIndexesWithTypeAndFlagsValue (lldb::SymbolType symbol_type, uint32_t flags_value, std::vector<uint32_t>& indexes, uint32_t start_idx = 0, uint32_t end_index = UINT32_MAX) const;
@ -114,7 +114,7 @@ protected:
private:
bool
CheckSymbolAtIndex (uint32_t idx, Debug symbol_debug_type, Visibility symbol_visibility) const
CheckSymbolAtIndex (size_t idx, Debug symbol_debug_type, Visibility symbol_visibility) const
{
switch (symbol_debug_type)
{

6
lldb/include/lldb/Symbol/Variable.h
View File

@ -144,9 +144,9 @@ public:
m_loc_is_const_data = b;
}
typedef uint32_t (*GetVariableCallback) (void *baton,
const char *name,
VariableList &var_list);
typedef size_t (*GetVariableCallback) (void *baton,
const char *name,
VariableList &var_list);
static Error

4
lldb/include/lldb/Symbol/VariableList.h
View File

@ -42,10 +42,10 @@ public:
Dump(Stream *s, bool show_context) const;
lldb::VariableSP
GetVariableAtIndex(uint32_t idx) const;
GetVariableAtIndex(size_t idx) const;
lldb::VariableSP
RemoveVariableAtIndex (uint32_t idx);
RemoveVariableAtIndex (size_t idx);
lldb::VariableSP
FindVariable (const ConstString& name);

8
lldb/include/lldb/Target/Platform.h
View File

@ -480,13 +480,13 @@ namespace lldb_private {
}
// Used for column widths
uint32_t
size_t
GetMaxUserIDNameLength() const
{
return m_max_uid_name_len;
}
// Used for column widths
uint32_t
size_t
GetMaxGroupIDNameLength() const
{
return m_max_gid_name_len;
@ -550,8 +550,8 @@ namespace lldb_private {
Mutex m_gid_map_mutex;
IDToNameMap m_uid_map;
IDToNameMap m_gid_map;
uint32_t m_max_uid_name_len;
uint32_t m_max_gid_name_len;
size_t m_max_uid_name_len;
size_t m_max_gid_name_len;
const char *
GetCachedUserName (uint32_t uid)

16
lldb/include/lldb/Target/Process.h
View File

@ -637,7 +637,7 @@ public:
const FileAction *
GetFileActionForFD (int fd) const
{
for (uint32_t idx=0, count=m_file_actions.size(); idx < count; ++idx)
for (size_t idx=0, count=m_file_actions.size(); idx < count; ++idx)
{
if (m_file_actions[idx].GetFD () == fd)
return &m_file_actions[idx];
@ -1069,7 +1069,7 @@ public:
m_infos.clear();
}
uint32_t
size_t
GetSize()
{
return m_infos.size();
@ -1082,7 +1082,7 @@ public:
}
const char *
GetProcessNameAtIndex (uint32_t idx)
GetProcessNameAtIndex (size_t idx)
{
if (idx < m_infos.size())
return m_infos[idx].GetName();
@ -1090,7 +1090,7 @@ public:
}
size_t
GetProcessNameLengthAtIndex (uint32_t idx)
GetProcessNameLengthAtIndex (size_t idx)
{
if (idx < m_infos.size())
return m_infos[idx].GetNameLength();
@ -1098,7 +1098,7 @@ public:
}
lldb::pid_t
GetProcessIDAtIndex (uint32_t idx)
GetProcessIDAtIndex (size_t idx)
{
if (idx < m_infos.size())
return m_infos[idx].GetProcessID();
@ -1106,7 +1106,7 @@ public:
}
bool
GetInfoAtIndex (uint32_t idx, ProcessInstanceInfo &info)
GetInfoAtIndex (size_t idx, ProcessInstanceInfo &info)
{
if (idx < m_infos.size())
{
@ -1118,7 +1118,7 @@ public:
// You must ensure "idx" is valid before calling this function
const ProcessInstanceInfo &
GetProcessInfoAtIndex (uint32_t idx) const
GetProcessInfoAtIndex (size_t idx) const
{
assert (idx < m_infos.size());
return m_infos[idx];
@ -2769,7 +2769,7 @@ public:
size_t
WriteScalarToMemory (lldb::addr_t vm_addr,
const Scalar &scalar,
uint32_t size,
size_t size,
Error &error);
size_t

4
lldb/include/lldb/Target/RegisterContext.h
View File

@ -45,13 +45,13 @@ public:
GetRegisterCount () = 0;
virtual const RegisterInfo *
GetRegisterInfoAtIndex (uint32_t reg) = 0;
GetRegisterInfoAtIndex (size_t reg) = 0;
virtual size_t
GetRegisterSetCount () = 0;
virtual const RegisterSet *
GetRegisterSet (uint32_t reg_set) = 0;
GetRegisterSet (size_t reg_set) = 0;
virtual bool
ReadRegister (const RegisterInfo *reg_info, RegisterValue &reg_value) = 0;

1
lldb/include/lldb/lldb-defines.h
View File

@ -77,6 +77,7 @@
#define LLDB_INVALID_THREAD_ID 0
#define LLDB_INVALID_FRAME_ID UINT32_MAX
#define LLDB_INVALID_SIGNAL_NUMBER INT32_MAX
#define LLDB_INVALID_OFFSET UINT64_MAX // Must match max of lldb::offset_t
//----------------------------------------------------------------------
/// CPU Type defintions

1
lldb/include/lldb/lldb-types.h
View File

@ -74,6 +74,7 @@ namespace lldb
typedef uint64_t user_id_t;
typedef uint64_t pid_t;
typedef uint64_t tid_t;
typedef uint64_t offset_t;
typedef int32_t break_id_t;
typedef int32_t watch_id_t;
typedef void * clang_type_t;

28
lldb/scripts/Python/interface/SBData.i
View File

@ -42,50 +42,50 @@ public:
SetByteOrder (lldb::ByteOrder endian);
float
GetFloat (lldb::SBError& error, uint32_t offset);
GetFloat (lldb::SBError& error, lldb::offset_t offset);
double
GetDouble (lldb::SBError& error, uint32_t offset);
GetDouble (lldb::SBError& error, lldb::offset_t offset);
long double
GetLongDouble (lldb::SBError& error, uint32_t offset);
GetLongDouble (lldb::SBError& error, lldb::offset_t offset);
lldb::addr_t
GetAddress (lldb::SBError& error, uint32_t offset);
GetAddress (lldb::SBError& error, lldb::offset_t offset);
uint8_t
GetUnsignedInt8 (lldb::SBError& error, uint32_t offset);
GetUnsignedInt8 (lldb::SBError& error, lldb::offset_t offset);
uint16_t
GetUnsignedInt16 (lldb::SBError& error, uint32_t offset);
GetUnsignedInt16 (lldb::SBError& error, lldb::offset_t offset);
uint32_t
GetUnsignedInt32 (lldb::SBError& error, uint32_t offset);
GetUnsignedInt32 (lldb::SBError& error, lldb::offset_t offset);
uint64_t
GetUnsignedInt64 (lldb::SBError& error, uint32_t offset);
GetUnsignedInt64 (lldb::SBError& error, lldb::offset_t offset);
int8_t
GetSignedInt8 (lldb::SBError& error, uint32_t offset);
GetSignedInt8 (lldb::SBError& error, lldb::offset_t offset);
int16_t
GetSignedInt16 (lldb::SBError& error, uint32_t offset);
GetSignedInt16 (lldb::SBError& error, lldb::offset_t offset);
int32_t
GetSignedInt32 (lldb::SBError& error, uint32_t offset);
GetSignedInt32 (lldb::SBError& error, lldb::offset_t offset);
int64_t
GetSignedInt64 (lldb::SBError& error, uint32_t offset);
GetSignedInt64 (lldb::SBError& error, lldb::offset_t offset);
const char*
GetString (lldb::SBError& error, uint32_t offset);
GetString (lldb::SBError& error, lldb::offset_t offset);
bool
GetDescription (lldb::SBStream &description, lldb::addr_t base_addr);
size_t
ReadRawData (lldb::SBError& error,
uint32_t offset,
lldb::offset_t offset,
void *buf,
size_t size);

56
lldb/source/API/SBData.cpp
View File

@ -151,7 +151,7 @@ SBData::SetByteOrder (lldb::ByteOrder endian)
float
SBData::GetFloat (lldb::SBError& error, uint32_t offset)
SBData::GetFloat (lldb::SBError& error, lldb::offset_t offset)
{
LogSP log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_API));
float value = 0;
@ -167,13 +167,13 @@ SBData::GetFloat (lldb::SBError& error, uint32_t offset)
error.SetErrorString("unable to read data");
}
if (log)
log->Printf ("SBData::GetFloat (error=%p,offset=%d) => "
log->Printf ("SBData::GetFloat (error=%p,offset=%" PRIu64 ") => "
"(%f)", error.get(), offset, value);
return value;
}
double
SBData::GetDouble (lldb::SBError& error, uint32_t offset)
SBData::GetDouble (lldb::SBError& error, lldb::offset_t offset)
{
LogSP log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_API));
double value = 0;
@ -189,13 +189,13 @@ SBData::GetDouble (lldb::SBError& error, uint32_t offset)
error.SetErrorString("unable to read data");
}
if (log)
log->Printf ("SBData::GetDouble (error=%p,offset=%d) => "
log->Printf ("SBData::GetDouble (error=%p,offset=%" PRIu64 ") => "
"(%f)", error.get(), offset, value);
return value;
}
long double
SBData::GetLongDouble (lldb::SBError& error, uint32_t offset)
SBData::GetLongDouble (lldb::SBError& error, lldb::offset_t offset)
{
LogSP log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_API));
long double value = 0;
@ -211,13 +211,13 @@ SBData::GetLongDouble (lldb::SBError& error, uint32_t offset)
error.SetErrorString("unable to read data");
}
if (log)
log->Printf ("SBData::GetLongDouble (error=%p,offset=%d) => "
log->Printf ("SBData::GetLongDouble (error=%p,offset=%" PRIu64 ") => "
"(%Lf)", error.get(), offset, value);
return value;
}
lldb::addr_t
SBData::GetAddress (lldb::SBError& error, uint32_t offset)
SBData::GetAddress (lldb::SBError& error, lldb::offset_t offset)
{
LogSP log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_API));
lldb::addr_t value = 0;
@ -233,13 +233,13 @@ SBData::GetAddress (lldb::SBError& error, uint32_t offset)
error.SetErrorString("unable to read data");
}
if (log)
log->Printf ("SBData::GetAddress (error=%p,offset=%d) => "
log->Printf ("SBData::GetAddress (error=%p,offset=%" PRIu64 ") => "
"(%p)", error.get(), offset, (void*)value);
return value;
}
uint8_t
SBData::GetUnsignedInt8 (lldb::SBError& error, uint32_t offset)
SBData::GetUnsignedInt8 (lldb::SBError& error, lldb::offset_t offset)
{
LogSP log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_API));
uint8_t value = 0;
@ -255,13 +255,13 @@ SBData::GetUnsignedInt8 (lldb::SBError& error, uint32_t offset)
error.SetErrorString("unable to read data");
}
if (log)
log->Printf ("SBData::GetUnsignedInt8 (error=%p,offset=%d) => "
log->Printf ("SBData::GetUnsignedInt8 (error=%p,offset=%" PRIu64 ") => "
"(%c)", error.get(), offset, value);
return value;
}
uint16_t
SBData::GetUnsignedInt16 (lldb::SBError& error, uint32_t offset)
SBData::GetUnsignedInt16 (lldb::SBError& error, lldb::offset_t offset)
{
LogSP log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_API));
uint16_t value = 0;
@ -277,13 +277,13 @@ SBData::GetUnsignedInt16 (lldb::SBError& error, uint32_t offset)
error.SetErrorString("unable to read data");
}
if (log)
log->Printf ("SBData::GetUnsignedInt16 (error=%p,offset=%d) => "
log->Printf ("SBData::GetUnsignedInt16 (error=%p,offset=%" PRIu64 ") => "
"(%hd)", error.get(), offset, value);
return value;
}
uint32_t
SBData::GetUnsignedInt32 (lldb::SBError& error, uint32_t offset)
SBData::GetUnsignedInt32 (lldb::SBError& error, lldb::offset_t offset)
{
LogSP log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_API));
uint32_t value = 0;
@ -299,13 +299,13 @@ SBData::GetUnsignedInt32 (lldb::SBError& error, uint32_t offset)
error.SetErrorString("unable to read data");
}
if (log)
log->Printf ("SBData::GetUnsignedInt32 (error=%p,offset=%d) => "
log->Printf ("SBData::GetUnsignedInt32 (error=%p,offset=%" PRIu64 ") => "
"(%d)", error.get(), offset, value);
return value;
}
uint64_t
SBData::GetUnsignedInt64 (lldb::SBError& error, uint32_t offset)
SBData::GetUnsignedInt64 (lldb::SBError& error, lldb::offset_t offset)
{
LogSP log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_API));
uint64_t value = 0;
@ -321,13 +321,13 @@ SBData::GetUnsignedInt64 (lldb::SBError& error, uint32_t offset)
error.SetErrorString("unable to read data");
}
if (log)
log->Printf ("SBData::GetUnsignedInt64 (error=%p,offset=%d) => "
log->Printf ("SBData::GetUnsignedInt64 (error=%p,offset=%" PRIu64 ") => "
"(%" PRId64 ")", error.get(), offset, value);
return value;
}
int8_t
SBData::GetSignedInt8 (lldb::SBError& error, uint32_t offset)
SBData::GetSignedInt8 (lldb::SBError& error, lldb::offset_t offset)
{
LogSP log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_API));
int8_t value = 0;
@ -343,13 +343,13 @@ SBData::GetSignedInt8 (lldb::SBError& error, uint32_t offset)
error.SetErrorString("unable to read data");
}
if (log)
log->Printf ("SBData::GetSignedInt8 (error=%p,offset=%d) => "
log->Printf ("SBData::GetSignedInt8 (error=%p,offset=%" PRIu64 ") => "
"(%c)", error.get(), offset, value);
return value;
}
int16_t
SBData::GetSignedInt16 (lldb::SBError& error, uint32_t offset)
SBData::GetSignedInt16 (lldb::SBError& error, lldb::offset_t offset)
{
LogSP log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_API));
int16_t value = 0;
@ -365,13 +365,13 @@ SBData::GetSignedInt16 (lldb::SBError& error, uint32_t offset)
error.SetErrorString("unable to read data");
}
if (log)
log->Printf ("SBData::GetSignedInt16 (error=%p,offset=%d) => "
log->Printf ("SBData::GetSignedInt16 (error=%p,offset=%" PRIu64 ") => "
"(%hd)", error.get(), offset, value);
return value;
}
int32_t
SBData::GetSignedInt32 (lldb::SBError& error, uint32_t offset)
SBData::GetSignedInt32 (lldb::SBError& error, lldb::offset_t offset)
{
LogSP log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_API));
int32_t value = 0;
@ -387,13 +387,13 @@ SBData::GetSignedInt32 (lldb::SBError& error, uint32_t offset)
error.SetErrorString("unable to read data");
}
if (log)
log->Printf ("SBData::GetSignedInt32 (error=%p,offset=%d) => "
log->Printf ("SBData::GetSignedInt32 (error=%p,offset=%" PRIu64 ") => "
"(%d)", error.get(), offset, value);
return value;
}
int64_t
SBData::GetSignedInt64 (lldb::SBError& error, uint32_t offset)
SBData::GetSignedInt64 (lldb::SBError& error, lldb::offset_t offset)
{
LogSP log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_API));
int64_t value = 0;
@ -409,13 +409,13 @@ SBData::GetSignedInt64 (lldb::SBError& error, uint32_t offset)
error.SetErrorString("unable to read data");
}
if (log)
log->Printf ("SBData::GetSignedInt64 (error=%p,offset=%d) => "
log->Printf ("SBData::GetSignedInt64 (error=%p,offset=%" PRIu64 ") => "
"(%" PRId64 ")", error.get(), offset, value);
return value;
}
const char*
SBData::GetString (lldb::SBError& error, uint32_t offset)
SBData::GetString (lldb::SBError& error, lldb::offset_t offset)
{
LogSP log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_API));
const char* value = 0;
@ -431,7 +431,7 @@ SBData::GetString (lldb::SBError& error, uint32_t offset)
error.SetErrorString("unable to read data");
}
if (log)
log->Printf ("SBData::GetString (error=%p,offset=%d) => "
log->Printf ("SBData::GetString (error=%p,offset=%" PRIu64 ") => "
"(%p)", error.get(), offset, value);
return value;
}
@ -461,7 +461,7 @@ SBData::GetDescription (lldb::SBStream &description, lldb::addr_t base_addr)
size_t
SBData::ReadRawData (lldb::SBError& error,
uint32_t offset,
lldb::offset_t offset,
void *buf,
size_t size)
{
@ -479,7 +479,7 @@ SBData::ReadRawData (lldb::SBError& error,
error.SetErrorString("unable to read data");
}
if (log)
log->Printf ("SBData::ReadRawData (error=%p,offset=%d,buf=%p,size=%lu) => "
log->Printf ("SBData::ReadRawData (error=%p,offset=%" PRIu64 ",buf=%p,size=%lu) => "
"(%p)", error.get(), offset, buf, size, ok);
return ok ? size : 0;
}

4
lldb/source/Breakpoint/Breakpoint.cpp
View File

@ -108,7 +108,7 @@ Breakpoint::FindLocationByID (break_id_t bp_loc_id)
}
BreakpointLocationSP
Breakpoint::GetLocationAtIndex (uint32_t index)
Breakpoint::GetLocationAtIndex (size_t index)
{
return m_locations.GetByIndex(index);
}
@ -760,7 +760,7 @@ Breakpoint::BreakpointEventData::GetBreakpointFromEvent (const EventSP &event_sp
return bp_sp;
}
uint32_t
size_t
Breakpoint::BreakpointEventData::GetNumBreakpointLocationsFromEvent (const EventSP &event_sp)
{
const BreakpointEventData *data = GetEventDataFromEvent (event_sp.get());

22
lldb/source/Breakpoint/BreakpointIDList.cpp
View File

@ -38,7 +38,7 @@ BreakpointIDList::GetSize()
}
BreakpointID &
BreakpointIDList::GetBreakpointIDAtIndex (uint32_t index)
BreakpointIDList::GetBreakpointIDAtIndex (size_t index)
{
if (index < m_breakpoint_ids.size())
return m_breakpoint_ids[index];
@ -47,7 +47,7 @@ BreakpointIDList::GetBreakpointIDAtIndex (uint32_t index)
}
bool
BreakpointIDList::RemoveBreakpointIDAtIndex (uint32_t index)
BreakpointIDList::RemoveBreakpointIDAtIndex (size_t index)
{
if (index >= m_breakpoint_ids.size())
return false;
@ -89,10 +89,8 @@ BreakpointIDList::AddBreakpointID (const char *bp_id_str)
}
bool
BreakpointIDList::FindBreakpointID (BreakpointID &bp_id, uint32_t *position)
BreakpointIDList::FindBreakpointID (BreakpointID &bp_id, size_t *position)
{
BreakpointIDArray::iterator tmp_pos;
for (size_t i = 0; i < m_breakpoint_ids.size(); ++i)
{
BreakpointID tmp_id = m_breakpoint_ids[i];
@ -108,7 +106,7 @@ BreakpointIDList::FindBreakpointID (BreakpointID &bp_id, uint32_t *position)
}
bool
BreakpointIDList::FindBreakpointID (const char *bp_id_str, uint32_t *position)
BreakpointIDList::FindBreakpointID (const char *bp_id_str, size_t *position)
{
BreakpointID temp_bp_id;
break_id_t bp_id;
@ -124,7 +122,7 @@ BreakpointIDList::FindBreakpointID (const char *bp_id_str, uint32_t *position)
}
void
BreakpointIDList::InsertStringArray (const char **string_array, uint32_t array_size, CommandReturnObject &result)
BreakpointIDList::InsertStringArray (const char **string_array, size_t array_size, CommandReturnObject &result)
{
if (string_array == NULL)
return;
@ -174,8 +172,8 @@ BreakpointIDList::FindAndReplaceIDRanges (Args &old_args, Target *target, Comman
bool is_range = false;
current_arg = old_args.GetArgumentAtIndex (i);
uint32_t range_start_len = 0;
uint32_t range_end_pos = 0;
size_t range_start_len = 0;
size_t range_end_pos = 0;
if (BreakpointIDList::StringContainsIDRangeExpression (current_arg, &range_start_len, &range_end_pos))
{
is_range = true;
@ -350,8 +348,8 @@ BreakpointIDList::FindAndReplaceIDRanges (Args &old_args, Target *target, Comman
bool
BreakpointIDList::StringContainsIDRangeExpression (const char *in_string,
uint32_t *range_start_len,
uint32_t *range_end_pos)
size_t *range_start_len,
size_t *range_end_pos)
{
bool is_range_expression = false;
std::string arg_str = in_string;
@ -368,7 +366,7 @@ BreakpointIDList::StringContainsIDRangeExpression (const char *in_string,
for (int i = 0; i < specifiers_size && !is_range_expression; ++i)
{
const char *specifier_str = BreakpointID::g_range_specifiers[i];
int len = strlen (specifier_str);
size_t len = strlen (specifier_str);
idx = arg_str.find (BreakpointID::g_range_specifiers[i]);
if (idx != std::string::npos)
{

8
lldb/source/Breakpoint/BreakpointList.cpp
View File

@ -172,13 +172,13 @@ BreakpointList::Dump (Stream *s) const
BreakpointSP
BreakpointList::GetBreakpointAtIndex (uint32_t i)
BreakpointList::GetBreakpointAtIndex (size_t i)
{
Mutex::Locker locker(m_mutex);
BreakpointSP stop_sp;
bp_collection::iterator end = m_breakpoints.end();
bp_collection::iterator pos;
uint32_t curr_i = 0;
size_t curr_i = 0;
for (pos = m_breakpoints.begin(), curr_i = 0; pos != end; ++pos, ++curr_i)
{
if (curr_i == i)
@ -188,13 +188,13 @@ BreakpointList::GetBreakpointAtIndex (uint32_t i)
}
const BreakpointSP
BreakpointList::GetBreakpointAtIndex (uint32_t i) const
BreakpointList::GetBreakpointAtIndex (size_t i) const
{
Mutex::Locker locker(m_mutex);
BreakpointSP stop_sp;
bp_collection::const_iterator end = m_breakpoints.end();
bp_collection::const_iterator pos;
uint32_t curr_i = 0;
size_t curr_i = 0;
for (pos = m_breakpoints.begin(), curr_i = 0; pos != end; ++pos, ++curr_i)
{
if (curr_i == i)

4
lldb/source/Breakpoint/BreakpointLocationCollection.cpp
View File

@ -115,7 +115,7 @@ BreakpointLocationCollection::FindByIDPair (lldb::break_id_t break_id, lldb::bre
}
BreakpointLocationSP
BreakpointLocationCollection::GetByIndex (uint32_t i)
BreakpointLocationCollection::GetByIndex (size_t i)
{
BreakpointLocationSP stop_sp;
if (i < m_break_loc_collection.size())
@ -125,7 +125,7 @@ BreakpointLocationCollection::GetByIndex (uint32_t i)
}
const BreakpointLocationSP
BreakpointLocationCollection::GetByIndex (uint32_t i) const
BreakpointLocationCollection::GetByIndex (size_t i) const
{
BreakpointLocationSP stop_sp;
if (i < m_break_loc_collection.size())

4
lldb/source/Breakpoint/BreakpointLocationList.cpp
View File

@ -138,7 +138,7 @@ BreakpointLocationList::Dump (Stream *s) const
BreakpointLocationSP
BreakpointLocationList::GetByIndex (uint32_t i)
BreakpointLocationList::GetByIndex (size_t i)
{
Mutex::Locker locker (m_mutex);
BreakpointLocationSP bp_loc_sp;
@ -149,7 +149,7 @@ BreakpointLocationList::GetByIndex (uint32_t i)
}
const BreakpointLocationSP
BreakpointLocationList::GetByIndex (uint32_t i) const
BreakpointLocationList::GetByIndex (size_t i) const
{
Mutex::Locker locker (m_mutex);
BreakpointLocationSP bp_loc_sp;

4
lldb/source/Breakpoint/BreakpointResolverFileLine.cpp
View File

@ -73,8 +73,8 @@ BreakpointResolverFileLine::SearchCallback
// So we go through the match list and pull out the sets that have the same file spec in their line_entry
// and treat each set separately.
uint32_t num_comp_units = context.module_sp->GetNumCompileUnits();
for (uint32_t i = 0; i < num_comp_units; i++)
const size_t num_comp_units = context.module_sp->GetNumCompileUnits();
for (size_t i = 0; i < num_comp_units; i++)
{
CompUnitSP cu_sp (context.module_sp->GetCompileUnitAtIndex (i));
if (cu_sp)

14
lldb/source/Breakpoint/BreakpointResolverName.cpp
View File

@ -170,13 +170,13 @@ BreakpointResolverName::SearchCallback
size_t num_names = m_func_names.size();
for (int j = 0; j < num_names; j++)
{
uint32_t num_functions = context.module_sp->FindFunctions (m_func_names[j],
NULL,
m_func_name_type_mask,
include_symbols,
include_inlines,
append,
func_list);
size_t num_functions = context.module_sp->FindFunctions (m_func_names[j],
NULL,
m_func_name_type_mask,
include_symbols,
include_inlines,
append,
func_list);
// If the search filter specifies a Compilation Unit, then we don't need to bother to look in plain
// symbols, since all the ones from a set compilation unit will have been found above already.

11
lldb/source/Breakpoint/BreakpointSite.cpp
View File

@ -25,10 +25,9 @@ BreakpointSite::BreakpointSite
BreakpointSiteList *list,
const BreakpointLocationSP& owner,
lldb::addr_t addr,
lldb::tid_t tid,
bool use_hardware
) :
StoppointLocation(GetNextID(), addr, tid, use_hardware),
StoppointLocation(GetNextID(), addr, 0, use_hardware),
m_type (eSoftware), // Process subclasses need to set this correctly using SetType()
m_saved_opcode(),
m_trap_opcode(),
@ -118,7 +117,7 @@ BreakpointSite::GetTrapOpcodeMaxByteSize() const
}
bool
BreakpointSite::SetTrapOpcode (const uint8_t *trap_opcode, size_t trap_opcode_size)
BreakpointSite::SetTrapOpcode (const uint8_t *trap_opcode, uint32_t trap_opcode_size)
{
if (trap_opcode_size > 0 && trap_opcode_size <= sizeof(m_trap_opcode))
{
@ -160,21 +159,21 @@ BreakpointSite::AddOwner (const BreakpointLocationSP &owner)
m_owners.Add(owner);
}
uint32_t
size_t
BreakpointSite::RemoveOwner (lldb::break_id_t break_id, lldb::break_id_t break_loc_id)
{
m_owners.Remove(break_id, break_loc_id);
return m_owners.GetSize();
}
uint32_t
size_t
BreakpointSite::GetNumberOfOwners ()
{
return m_owners.GetSize();
}
BreakpointLocationSP
BreakpointSite::GetOwnerAtIndex (uint32_t index)
BreakpointSite::GetOwnerAtIndex (size_t index)
{
return m_owners.GetByIndex (index);
}

2
lldb/source/Breakpoint/Watchpoint.cpp
View File

@ -27,7 +27,7 @@
using namespace lldb;
using namespace lldb_private;
Watchpoint::Watchpoint (Target& target, lldb::addr_t addr, size_t size, const ClangASTType *type, bool hardware) :
Watchpoint::Watchpoint (Target& target, lldb::addr_t addr, uint32_t size, const ClangASTType *type, bool hardware) :
StoppointLocation (0, addr, size, hardware),
m_target(target),
m_enabled(false),

2
lldb/source/Commands/CommandCompletions.cpp
View File

@ -131,7 +131,7 @@ DiskFilesOrDirectories
// I'm going to use the "glob" function with GLOB_TILDE for user directory expansion.
// If it is not defined on your host system, you'll need to implement it yourself...
int partial_name_len = strlen(partial_file_name);
size_t partial_name_len = strlen(partial_file_name);
if (partial_name_len >= PATH_MAX)
return matches.GetSize();

2
lldb/source/Commands/CommandObjectApropos.cpp
View File

@ -56,7 +56,7 @@ CommandObjectApropos::~CommandObjectApropos()
bool
CommandObjectApropos::DoExecute (Args& args, CommandReturnObject &result)
{
const int argc = args.GetArgumentCount ();
const size_t argc = args.GetArgumentCount ();
if (argc == 1)
{

2
lldb/source/Commands/CommandObjectArgs.cpp
View File

@ -120,7 +120,7 @@ CommandObjectArgs::DoExecute (Args& args, CommandReturnObject &result)
return false;
}
int num_args = args.GetArgumentCount ();
const size_t num_args = args.GetArgumentCount ();
int arg_index;
if (!num_args)

6
lldb/source/Commands/CommandObjectBreakpoint.cpp
View File

@ -396,7 +396,7 @@ protected:
case eSetTypeFileAndLine: // Breakpoint by source position
{
FileSpec file;
uint32_t num_files = m_options.m_filenames.GetSize();
const size_t num_files = m_options.m_filenames.GetSize();
if (num_files == 0)
{
if (!GetDefaultFile (target, file, result))
@ -469,7 +469,7 @@ protected:
break;
case eSetTypeSourceRegexp: // Breakpoint by regexp on source text.
{
int num_files = m_options.m_filenames.GetSize();
const size_t num_files = m_options.m_filenames.GetSize();
if (num_files == 0)
{
@ -1794,7 +1794,7 @@ CommandObjectMultiwordBreakpoint::VerifyBreakpointIDs (Args &args, Target *targe
Breakpoint *breakpoint = target->GetBreakpointByID (cur_bp_id.GetBreakpointID()).get();
if (breakpoint != NULL)
{
int num_locations = breakpoint->GetNumLocations();
const size_t num_locations = breakpoint->GetNumLocations();
if (cur_bp_id.GetLocationID() > num_locations)
{
StreamString id_str;

6
lldb/source/Commands/CommandObjectCommands.cpp
View File

@ -188,7 +188,7 @@ public:
return "";
}
int
virtual int
HandleArgumentCompletion (Args &input,
int &cursor_index,
int &cursor_char_position,
@ -285,7 +285,7 @@ protected:
bool
DoExecute(Args& command, CommandReturnObject &result)
{
const int argc = command.GetArgumentCount();
const size_t argc = command.GetArgumentCount();
if (argc == 1)
{
const char *filename = command.GetArgumentAtIndex(0);
@ -1289,7 +1289,7 @@ public:
{
}
int
virtual int
HandleArgumentCompletion (Args &input,
int &cursor_index,
int &cursor_char_position,

2
lldb/source/Commands/CommandObjectExpression.cpp
View File

@ -424,7 +424,7 @@ CommandObjectExpression::EvaluateExpression
const char *error_cstr = result_valobj_sp->GetError().AsCString();
if (error_cstr && error_cstr[0])
{
int error_cstr_len = strlen (error_cstr);
const size_t error_cstr_len = strlen (error_cstr);
const bool ends_with_newline = error_cstr[error_cstr_len - 1] == '\n';
if (strstr(error_cstr, "error:") != error_cstr)
error_stream->PutCString ("error: ");

8
lldb/source/Commands/CommandObjectFrame.cpp
View File

@ -419,7 +419,7 @@ protected:
{
if (m_option_variable.use_regex)
{
const uint32_t regex_start_index = regex_var_list.GetSize();
const size_t regex_start_index = regex_var_list.GetSize();
RegularExpression regex (name_cstr);
if (regex.Compile(name_cstr))
{
@ -429,7 +429,7 @@ protected:
num_matches);
if (num_new_regex_vars > 0)
{
for (uint32_t regex_idx = regex_start_index, end_index = regex_var_list.GetSize();
for (size_t regex_idx = regex_start_index, end_index = regex_var_list.GetSize();
regex_idx < end_index;
++regex_idx)
{
@ -512,10 +512,10 @@ protected:
}
else // No command arg specified. Use variable_list, instead.
{
const uint32_t num_variables = variable_list->GetSize();
const size_t num_variables = variable_list->GetSize();
if (num_variables > 0)
{
for (uint32_t i=0; i<num_variables; i++)
for (size_t i=0; i<num_variables; i++)
{
var_sp = variable_list->GetVariableAtIndex(i);
bool dump_variable = true;

6
lldb/source/Commands/CommandObjectHelp.cpp
View File

@ -64,7 +64,7 @@ CommandObjectHelp::DoExecute (Args& command, CommandReturnObject &result)
{
CommandObject::CommandMap::iterator pos;
CommandObject *cmd_obj;
const int argc = command.GetArgumentCount ();
const size_t argc = command.GetArgumentCount ();
// 'help' doesn't take any arguments, other than command names. If argc is 0, we show the user
// all commands (aliases and user commands if asked for). Otherwise every argument must be the name of a command or a sub-command.
@ -224,8 +224,8 @@ CommandObjectHelp::DoExecute (Args& command, CommandReturnObject &result)
{
Stream &output_strm = result.GetOutputStream();
output_strm.Printf("Help requested with ambiguous command name, possible completions:\n");
const uint32_t match_count = matches.GetSize();
for (uint32_t i = 0; i < match_count; i++)
const size_t match_count = matches.GetSize();
for (size_t i = 0; i < match_count; i++)
{
output_strm.Printf("\t%s\n", matches.GetStringAtIndex(i));
}

29
lldb/source/Commands/CommandObjectMemory.cpp
View File

@ -742,10 +742,10 @@ protected:
{
if (m_memory_options.m_output_as_binary)
{
int bytes_written = outfile_stream.Write (data_sp->GetBytes(), bytes_read);
const size_t bytes_written = outfile_stream.Write (data_sp->GetBytes(), bytes_read);
if (bytes_written > 0)
{
result.GetOutputStream().Printf ("%i bytes %s to '%s'\n",
result.GetOutputStream().Printf ("%zi bytes %s to '%s'\n",
bytes_written,
append ? "appended" : "written",
path);
@ -835,16 +835,16 @@ protected:
assert (output_stream);
uint32_t bytes_dumped = data.Dump (output_stream,
0,
m_format_options.GetFormat(),
item_byte_size,
item_count,
num_per_line,
addr,
0,
0,
exe_scope);
size_t bytes_dumped = data.Dump (output_stream,
0,
m_format_options.GetFormat(),
item_byte_size,
item_count,
num_per_line,
addr,
0,
0,
exe_scope);
m_next_addr = addr + bytes_dumped;
output_stream->EOL();
return true;
@ -1129,9 +1129,8 @@ protected:
uint64_t uval64;
int64_t sval64;
bool success = false;
const uint32_t num_value_args = command.GetArgumentCount();
uint32_t i;
for (i=0; i<num_value_args; ++i)
const size_t num_value_args = command.GetArgumentCount();
for (size_t i=0; i<num_value_args; ++i)
{
const char *value_str = command.GetArgumentAtIndex(i);

6
lldb/source/Commands/CommandObjectMultiword.cpp
View File

@ -143,7 +143,7 @@ CommandObjectMultiword::Execute(const char *args_string, CommandReturnObject &re
else
{
std::string error_msg;
int num_subcmd_matches = matches.GetSize();
const size_t num_subcmd_matches = matches.GetSize();
if (num_subcmd_matches > 0)
error_msg.assign ("ambiguous command ");
else
@ -158,14 +158,14 @@ CommandObjectMultiword::Execute(const char *args_string, CommandReturnObject &re
if (num_subcmd_matches > 0)
{
error_msg.append (" Possible completions:");
for (int i = 0; i < num_subcmd_matches; i++)
for (size_t i = 0; i < num_subcmd_matches; i++)
{
error_msg.append ("\n\t");
error_msg.append (matches.GetStringAtIndex (i));
}
}
error_msg.append ("\n");
result.AppendRawError (error_msg.c_str(), error_msg.size());
result.AppendRawError (error_msg.c_str());
result.SetStatus (eReturnStatusFailed);
}
}

2
lldb/source/Commands/CommandObjectPlatform.cpp
View File

@ -386,7 +386,7 @@ protected:
if (platform_sp)
{
Error error;
const uint32_t argc = args.GetArgumentCount();
const size_t argc = args.GetArgumentCount();
Target *target = m_exe_ctx.GetTargetPtr();
Module *exe_module = target->GetExecutableModulePointer();
if (exe_module)

16
lldb/source/Commands/CommandObjectProcess.cpp
View File

@ -69,7 +69,7 @@ public:
{
}
int
virtual int
HandleArgumentCompletion (Args &input,
int &cursor_index,
int &cursor_char_position,
@ -446,10 +446,10 @@ public:
match_info.SetNameMatchType(eNameMatchStartsWith);
}
platform_sp->FindProcesses (match_info, process_infos);
const uint32_t num_matches = process_infos.GetSize();
const size_t num_matches = process_infos.GetSize();
if (num_matches > 0)
{
for (uint32_t i=0; i<num_matches; ++i)
for (size_t i=0; i<num_matches; ++i)
{
matches.AppendString (process_infos.GetProcessNameAtIndex(i),
process_infos.GetProcessNameLengthAtIndex(i));
@ -773,12 +773,12 @@ protected:
StopInfoSP stop_info_sp = sel_thread_sp->GetStopInfo();
if (stop_info_sp && stop_info_sp->GetStopReason() == eStopReasonBreakpoint)
{
uint64_t bp_site_id = stop_info_sp->GetValue();
lldb::break_id_t bp_site_id = (lldb::break_id_t)stop_info_sp->GetValue();
BreakpointSiteSP bp_site_sp(process->GetBreakpointSiteList().FindByID(bp_site_id));
if (bp_site_sp)
{
uint32_t num_owners = bp_site_sp->GetNumberOfOwners();
for (uint32_t i = 0; i < num_owners; i++)
const size_t num_owners = bp_site_sp->GetNumberOfOwners();
for (size_t i = 0; i < num_owners; i++)
{
Breakpoint &bp_ref = bp_site_sp->GetOwnerAtIndex(i)->GetBreakpoint();
if (!bp_ref.IsInternal())
@ -1134,7 +1134,7 @@ protected:
{
Process *process = m_exe_ctx.GetProcessPtr();
const uint32_t argc = command.GetArgumentCount();
const size_t argc = command.GetArgumentCount();
for (uint32_t i=0; i<argc; ++i)
{
@ -1191,7 +1191,7 @@ protected:
{
Process *process = m_exe_ctx.GetProcessPtr();
const uint32_t argc = command.GetArgumentCount();
const size_t argc = command.GetArgumentCount();
for (uint32_t i=0; i<argc; ++i)
{

16
lldb/source/Commands/CommandObjectRegister.cpp
View File

@ -129,7 +129,7 @@ public:
DumpRegisterSet (const ExecutionContext &exe_ctx,
Stream &strm,
RegisterContext *reg_ctx,
uint32_t set_idx,
size_t set_idx,
bool primitive_only=false)
{
uint32_t unavailable_count = 0;
@ -139,8 +139,8 @@ public:
{
strm.Printf ("%s:\n", reg_set->name);
strm.IndentMore ();
const uint32_t num_registers = reg_set->num_registers;
for (uint32_t reg_idx = 0; reg_idx < num_registers; ++reg_idx)
const size_t num_registers = reg_set->num_registers;
for (size_t reg_idx = 0; reg_idx < num_registers; ++reg_idx)
{
const uint32_t reg = reg_set->registers[reg_idx];
const RegisterInfo *reg_info = reg_ctx->GetRegisterInfoAtIndex(reg);
@ -173,20 +173,20 @@ protected:
const RegisterInfo *reg_info = NULL;
if (command.GetArgumentCount() == 0)
{
uint32_t set_idx;
size_t set_idx;
uint32_t num_register_sets = 1;
const uint32_t set_array_size = m_command_options.set_indexes.GetSize();
size_t num_register_sets = 1;
const size_t set_array_size = m_command_options.set_indexes.GetSize();
if (set_array_size > 0)
{
for (uint32_t i=0; i<set_array_size; ++i)
for (size_t i=0; i<set_array_size; ++i)
{
set_idx = m_command_options.set_indexes[i]->GetUInt64Value (UINT32_MAX, NULL);
if (set_idx != UINT32_MAX)
{
if (!DumpRegisterSet (m_exe_ctx, strm, reg_ctx, set_idx))
{
result.AppendErrorWithFormat ("invalid register set index: %u\n", set_idx);
result.AppendErrorWithFormat ("invalid register set index: %zu\n", set_idx);
result.SetStatus (eReturnStatusFailed);
break;
}

15
lldb/source/Commands/CommandObjectSource.cpp
View File

@ -299,7 +299,7 @@ protected:
bool
DoExecute (Args& command, CommandReturnObject &result)
{
const int argc = command.GetArgumentCount();
const size_t argc = command.GetArgumentCount();
if (argc != 0)
{
@ -320,10 +320,11 @@ protected:
bool append = true;
size_t num_matches = 0;
if (m_options.modules.size() > 0)
const size_t num_modules = m_options.modules.size();
if (num_modules > 0)
{
ModuleList matching_modules;
for (unsigned i = 0, e = m_options.modules.size(); i != e; i++)
for (size_t i = 0; i < num_modules; ++i)
{
FileSpec module_file_spec(m_options.modules[i].c_str(), false);
if (module_file_spec)
@ -423,7 +424,7 @@ protected:
// This is a little hacky, but the first line table entry for a function points to the "{" that
// starts the function block. It would be nice to actually get the function
// declaration in there too. So back up a bit, but not further than what you're going to display.
size_t lines_to_back_up = m_options.num_lines >= 10 ? 5 : m_options.num_lines/2;
uint32_t lines_to_back_up = m_options.num_lines >= 10 ? 5 : m_options.num_lines/2;
uint32_t line_no;
if (start_line <= lines_to_back_up)
line_no = 1;
@ -475,8 +476,8 @@ protected:
// The target isn't loaded yet, we need to lookup the file address
// in all modules
const ModuleList &module_list = target->GetImages();
const uint32_t num_modules = module_list.GetSize();
for (uint32_t i=0; i<num_modules; ++i)
const size_t num_modules = module_list.GetSize();
for (size_t i=0; i<num_modules; ++i)
{
ModuleSP module_sp (module_list.GetModuleAtIndex(i));
if (module_sp && module_sp->ResolveFileAddress(m_options.address, so_addr))
@ -621,7 +622,7 @@ protected:
if (m_options.modules.size() > 0)
{
ModuleList matching_modules;
for (unsigned i = 0, e = m_options.modules.size(); i != e; i++)
for (size_t i = 0, e = m_options.modules.size(); i < e; ++i)
{
FileSpec module_file_spec(m_options.modules[i].c_str(), false);
if (module_file_spec)

2
lldb/source/Commands/CommandObjectSyntax.cpp
View File

@ -59,7 +59,7 @@ CommandObjectSyntax::DoExecute (Args& command, CommandReturnObject &result)
{
CommandObject::CommandMap::iterator pos;
CommandObject *cmd_obj;
const int argc = command.GetArgumentCount();
const size_t argc = command.GetArgumentCount();
if (argc > 0)
{

82
lldb/source/Commands/CommandObjectTarget.cpp
View File

@ -192,7 +192,7 @@ public:
return &m_option_group;
}
int
virtual int
HandleArgumentCompletion (Args &input,
int &cursor_index,
int &cursor_char_position,
@ -220,7 +220,7 @@ protected:
bool
DoExecute (Args& command, CommandReturnObject &result)
{
const int argc = command.GetArgumentCount();
const size_t argc = command.GetArgumentCount();
FileSpec core_file (m_core_file.GetOptionValue().GetCurrentValue());
if (argc == 1 || core_file)
@ -697,9 +697,9 @@ public:
}
static uint32_t GetVariableCallback (void *baton,
const char *name,
VariableList &variable_list)
static size_t GetVariableCallback (void *baton,
const char *name,
VariableList &variable_list)
{
Target *target = static_cast<Target *>(baton);
if (target)
@ -782,7 +782,7 @@ protected:
ValueObjectList valobj_list;
const char *arg = args.GetArgumentAtIndex(idx);
uint32_t matches = 0;
size_t matches = 0;
bool use_var_name = false;
if (m_option_variable.use_regex)
{
@ -1019,7 +1019,7 @@ protected:
Target *target = m_interpreter.GetDebugger().GetSelectedTarget().get();
if (target)
{
uint32_t argc = command.GetArgumentCount();
const size_t argc = command.GetArgumentCount();
if (argc & 1)
{
result.AppendError ("add requires an even number of arguments\n");
@ -1027,7 +1027,7 @@ protected:
}
else
{
for (uint32_t i=0; i<argc; i+=2)
for (size_t i=0; i<argc; i+=2)
{
const char *from = command.GetArgumentAtIndex(i);
const char *to = command.GetArgumentAtIndex(i+1);
@ -1156,7 +1156,7 @@ protected:
Target *target = m_interpreter.GetDebugger().GetSelectedTarget().get();
if (target)
{
uint32_t argc = command.GetArgumentCount();
size_t argc = command.GetArgumentCount();
// check for at least 3 arguments and an odd nubmer of parameters
if (argc >= 3 && argc & 1)
{
@ -1670,7 +1670,7 @@ DumpSymbolContextList (ExecutionContextScope *exe_scope, Stream &strm, SymbolCon
strm.IndentLess ();
}
static uint32_t
static size_t
LookupFunctionInModule (CommandInterpreter &interpreter,
Stream &strm,
Module *module,
@ -1684,7 +1684,7 @@ LookupFunctionInModule (CommandInterpreter &interpreter,
{
SymbolContextList sc_list;
const bool append = true;
uint32_t num_matches = 0;
size_t num_matches = 0;
if (name_is_regex)
{
RegularExpression function_name_regex (name);
@ -1709,7 +1709,7 @@ LookupFunctionInModule (CommandInterpreter &interpreter,
if (num_matches)
{
strm.Indent ();
strm.Printf("%u match%s found in ", num_matches, num_matches > 1 ? "es" : "");
strm.Printf("%zu match%s found in ", num_matches, num_matches > 1 ? "es" : "");
DumpFullpath (strm, &module->GetFileSpec(), 0);
strm.PutCString(":\n");
DumpSymbolContextList (interpreter.GetExecutionContext().GetBestExecutionContextScope(), strm, sc_list, verbose);
@ -1719,7 +1719,7 @@ LookupFunctionInModule (CommandInterpreter &interpreter,
return 0;
}
static uint32_t
static size_t
LookupTypeInModule (CommandInterpreter &interpreter,
Stream &strm,
Module *module,
@ -1730,7 +1730,7 @@ LookupTypeInModule (CommandInterpreter &interpreter,
{
TypeList type_list;
const uint32_t max_num_matches = UINT32_MAX;
uint32_t num_matches = 0;
size_t num_matches = 0;
bool name_is_fully_qualified = false;
SymbolContext sc;
@ -1740,7 +1740,7 @@ LookupTypeInModule (CommandInterpreter &interpreter,
if (num_matches)
{
strm.Indent ();
strm.Printf("%u match%s found in ", num_matches, num_matches > 1 ? "es" : "");
strm.Printf("%zu match%s found in ", num_matches, num_matches > 1 ? "es" : "");
DumpFullpath (strm, &module->GetFileSpec(), 0);
strm.PutCString(":\n");
const uint32_t num_types = type_list.GetSize();
@ -1774,7 +1774,7 @@ LookupTypeInModule (CommandInterpreter &interpreter,
return 0;
}
static uint32_t
static size_t
LookupTypeHere (CommandInterpreter &interpreter,
Stream &strm,
const SymbolContext &sym_ctx,
@ -1786,7 +1786,7 @@ LookupTypeHere (CommandInterpreter &interpreter,
TypeList type_list;
const uint32_t max_num_matches = UINT32_MAX;
uint32_t num_matches = 1;
size_t num_matches = 1;
bool name_is_fully_qualified = false;
ConstString name(name_cstr);
@ -1873,9 +1873,9 @@ FindModulesByName (Target *target,
{
// Check the global list
Mutex::Locker locker(Module::GetAllocationModuleCollectionMutex());
const uint32_t num_modules = Module::GetNumberAllocatedModules();
const size_t num_modules = Module::GetNumberAllocatedModules();
ModuleSP module_sp;
for (uint32_t image_idx = 0; image_idx<num_modules; ++image_idx)
for (size_t image_idx = 0; image_idx<num_modules; ++image_idx)
{
Module *module = Module::GetAllocatedModuleAtIndex(image_idx);
@ -2145,11 +2145,11 @@ protected:
{
// Dump all sections for all modules images
Mutex::Locker modules_locker(target->GetImages().GetMutex());
const uint32_t num_modules = target->GetImages().GetSize();
const size_t num_modules = target->GetImages().GetSize();
if (num_modules > 0)
{
result.GetOutputStream().Printf("Dumping symbol table for %u modules.\n", num_modules);
for (uint32_t image_idx = 0; image_idx<num_modules; ++image_idx)
result.GetOutputStream().Printf("Dumping symbol table for %zu modules.\n", num_modules);
for (size_t image_idx = 0; image_idx<num_modules; ++image_idx)
{
if (num_dumped > 0)
{
@ -2278,11 +2278,11 @@ protected:
if (command.GetArgumentCount() == 0)
{
// Dump all sections for all modules images
const uint32_t num_modules = target->GetImages().GetSize();
const size_t num_modules = target->GetImages().GetSize();
if (num_modules > 0)
{
result.GetOutputStream().Printf("Dumping sections for %u modules.\n", num_modules);
for (uint32_t image_idx = 0; image_idx<num_modules; ++image_idx)
result.GetOutputStream().Printf("Dumping sections for %zu modules.\n", num_modules);
for (size_t image_idx = 0; image_idx<num_modules; ++image_idx)
{
num_dumped++;
DumpModuleSections (m_interpreter, result.GetOutputStream(), target->GetImages().GetModulePointerAtIndex(image_idx));
@ -2386,10 +2386,10 @@ protected:
// Dump all sections for all modules images
const ModuleList &target_modules = target->GetImages();
Mutex::Locker modules_locker (target_modules.GetMutex());
const uint32_t num_modules = target_modules.GetSize();
const size_t num_modules = target_modules.GetSize();
if (num_modules > 0)
{
result.GetOutputStream().Printf("Dumping debug symbols for %u modules.\n", num_modules);
result.GetOutputStream().Printf("Dumping debug symbols for %zu modules.\n", num_modules);
for (uint32_t image_idx = 0; image_idx<num_modules; ++image_idx)
{
if (DumpModuleSymbolVendor (result.GetOutputStream(), target_modules.GetModulePointerAtIndexUnlocked(image_idx)))
@ -2491,7 +2491,7 @@ protected:
const ModuleList &target_modules = target->GetImages();
Mutex::Locker modules_locker(target_modules.GetMutex());
const uint32_t num_modules = target_modules.GetSize();
const size_t num_modules = target_modules.GetSize();
if (num_modules > 0)
{
uint32_t num_dumped = 0;
@ -2582,7 +2582,7 @@ public:
return &m_option_group;
}
int
virtual int
HandleArgumentCompletion (Args &input,
int &cursor_index,
int &cursor_char_position,
@ -3037,7 +3037,7 @@ public:
}
else
{
uint32_t width = 0;
unsigned long width = 0;
if (option_arg)
width = strtoul (option_arg, NULL, 0);
m_format_array.push_back(std::make_pair(short_option, width));
@ -3129,7 +3129,7 @@ protected:
ModuleSP module_sp (module_address.GetModule());
if (module_sp)
{
PrintModule (target, module_sp.get(), UINT32_MAX, 0, strm);
PrintModule (target, module_sp.get(), 0, strm);
result.SetStatus (eReturnStatusSuccessFinishResult);
}
else
@ -3152,7 +3152,7 @@ protected:
return result.Succeeded();
}
uint32_t num_modules = 0;
size_t num_modules = 0;
Mutex::Locker locker; // This locker will be locked on the mutex in module_list_ptr if it is non-NULL.
// Otherwise it will lock the AllocationModuleCollectionMutex when accessing
// the global module list directly.
@ -3214,8 +3214,8 @@ protected:
module_sp = module->shared_from_this();
}
int indent = strm.Printf("[%3u] ", image_idx);
PrintModule (target, module, image_idx, indent, strm);
const size_t indent = strm.Printf("[%3u] ", image_idx);
PrintModule (target, module, indent, strm);
}
result.SetStatus (eReturnStatusSuccessFinishResult);
@ -3244,7 +3244,7 @@ protected:
}
void
PrintModule (Target *target, Module *module, uint32_t idx, int indent, Stream &strm)
PrintModule (Target *target, Module *module, int indent, Stream &strm)
{
if (module == NULL)
@ -3338,7 +3338,7 @@ protected:
break;
case 'r':
{
uint32_t ref_count = 0;
size_t ref_count = 0;
ModuleSP module_sp (module->shared_from_this());
if (module_sp)
{
@ -3346,9 +3346,9 @@ protected:
ref_count = module_sp.use_count() - 1;
}
if (width)
strm.Printf("{%*u}", width, ref_count);
strm.Printf("{%*zu}", width, ref_count);
else
strm.Printf("{%u}", ref_count);
strm.Printf("{%zu}", ref_count);
}
break;
@ -3581,7 +3581,7 @@ protected:
if (m_options.m_type == eLookupTypeFunctionOrSymbol)
{
SymbolContextList sc_list;
uint32_t num_matches;
size_t num_matches;
ConstString function_name (m_options.m_str.c_str());
num_matches = target->GetImages().FindFunctions (function_name, eFunctionNameTypeAuto, true, false, true, sc_list);
for (uint32_t idx = 0; idx < num_matches; idx++)
@ -4038,7 +4038,7 @@ protected:
const ModuleList &target_modules = target->GetImages();
Mutex::Locker modules_locker(target_modules.GetMutex());
const uint32_t num_modules = target_modules.GetSize();
const size_t num_modules = target_modules.GetSize();
if (num_modules > 0)
{
for (i = 0; i<num_modules && syntax_error == false; ++i)
@ -4217,7 +4217,7 @@ public:
{
}
int
virtual int
HandleArgumentCompletion (Args &input,
int &cursor_index,
int &cursor_char_position,

Some files were not shown because too many files have changed in this diff Show More