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

Make ValueObject::SetValueFromCString work correctly. 

Also change the SourceInitFile to look for .lldb-<APPNAME> and source that
preferentially if it exists.
Also made the breakpoint site report its address as well as its breakpoint number
when it gets hit and can't find any the associated locations (usually because the
breakpoint got disabled or deleted programmatically between the time it was hit
and reported.)
Changed ThreadPlanCallFunction to initialize the ivar m_func in the initializers of the
constructor, rather than waiting to initialize till later on in the function.
Fixed a bug where if you make an SBError and the ask it Success, it returns false.
Fixed ValueObject::ResolveValue so that it resolves a temporary value, rather than
overwriting the one in the value object.

llvm-svn: 137536
This commit is contained in:
Jim Ingham 2011-08-12 23:34:31 +00:00
parent 729ed799c7
commit 16e0c68627
13 changed files with 151 additions and 95 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

3
lldb/include/lldb/API/SBDebugger.h
View File

@ -54,6 +54,9 @@ public:
void
SkipLLDBInitFiles (bool b);
void
SkipAppInitFiles (bool b);
void
SetInputFileHandle (FILE *f, bool transfer_ownership);

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

@ -343,6 +343,9 @@ public:
return m_update_point.GetExecutionContextScope();
}
void
SetNeedsUpdate ();
virtual ~ValueObject();
//------------------------------------------------------------------
@ -543,9 +546,6 @@ public:
DataExtractor &
GetDataExtractor ();
bool
Write ();
lldb::ValueObjectSP
GetSP ()
{

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

@ -156,6 +156,9 @@ public:
virtual uint32_t
CalculateNumChildren();
virtual bool
SetValueFromCString (const char *value_str);
protected:
virtual bool

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

@ -346,6 +346,12 @@ public:
m_skip_lldbinit_files = skip_lldbinit_files;
}
void
SkipAppInitFiles (bool skip_app_init_files)
{
m_skip_app_init_files = m_skip_lldbinit_files;
}
bool
GetSynchronous ();
@ -433,6 +439,7 @@ private:
ExecutionContext m_exe_ctx; // The current execution context to use when handling commands
bool m_synchronous_execution;
bool m_skip_lldbinit_files;
bool m_skip_app_init_files;
CommandObject::CommandMap m_command_dict; // Stores basic built-in commands (they cannot be deleted, removed or overwritten).
CommandObject::CommandMap m_alias_dict; // Stores user aliases/abbreviations for commands
CommandObject::CommandMap m_user_dict; // Stores user-defined commands

7
lldb/source/API/SBDebugger.cpp
View File

@ -149,6 +149,13 @@ SBDebugger::SkipLLDBInitFiles (bool b)
m_opaque_sp->GetCommandInterpreter().SkipLLDBInitFiles (b);
}
void
SBDebugger::SkipAppInitFiles (bool b)
{
if (m_opaque_sp)
m_opaque_sp->GetCommandInterpreter().SkipAppInitFiles (b);
}
// Shouldn't really be settable after initialization as this could cause lots of problems; don't want users
// trying to switch modes in the middle of a debugging session.
void

2
lldb/source/API/SBError.cpp
View File

@ -86,7 +86,7 @@ bool
SBError::Success () const
{
LogSP log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_API));
bool ret_value = false;
bool ret_value = true;
if (m_opaque_ap.get())
ret_value = m_opaque_ap->Success();

2
lldb/source/API/SBValue.cpp
View File

@ -629,6 +629,7 @@ SBValue::GetValueForExpressionPath(const char* expr_path)
int64_t
SBValue::GetValueAsSigned(SBError& error, int64_t fail_value)
{
error.Clear();
if (m_opaque_sp)
{
if (m_opaque_sp->GetUpdatePoint().GetTargetSP())
@ -650,6 +651,7 @@ SBValue::GetValueAsSigned(SBError& error, int64_t fail_value)
uint64_t
SBValue::GetValueAsUnsigned(SBError& error, uint64_t fail_value)
{
error.Clear();
if (m_opaque_sp)
{
if (m_opaque_sp->GetUpdatePoint().GetTargetSP())

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

@ -95,7 +95,7 @@ void
BreakpointSite::GetDescription (Stream *s, lldb::DescriptionLevel level)
{
if (level != lldb::eDescriptionLevelBrief)
s->Printf ("breakpoint site: %d ", GetID());
s->Printf ("breakpoint site: %d at 0x%8.8llx", GetID(), GetLoadAddress());
m_owners.GetDescription (s, level);
}

159
lldb/source/Core/ValueObject.cpp
View File

@ -252,6 +252,15 @@ ValueObject::UpdateFormatsIfNeeded(lldb::DynamicValueType use_dynamic)
}
}
void
ValueObject::SetNeedsUpdate ()
{
m_update_point.SetNeedsUpdate();
// We have to clear the value string here so ConstResult children will notice if their values are
// changed by hand (i.e. with SetValueAsCString).
m_value_str.clear();
}
DataExtractor &
ValueObject::GetDataExtractor ()
{
@ -338,7 +347,8 @@ ValueObject::ResolveValue (Scalar &scalar)
ExecutionContextScope *exe_scope = GetExecutionContextScope();
if (exe_scope)
exe_scope->CalculateExecutionContext(exe_ctx);
scalar = m_value.ResolveValue(&exe_ctx, GetClangAST ());
Value tmp_value(m_value);
scalar = tmp_value.ResolveValue(&exe_ctx, GetClangAST ());
return scalar.IsValid();
}
else
@ -1220,104 +1230,83 @@ ValueObject::SetValueFromCString (const char *value_str)
uint32_t count = 0;
lldb::Encoding encoding = ClangASTType::GetEncoding (GetClangType(), count);
char *end = NULL;
const size_t byte_size = GetByteSize();
switch (encoding)
{
case eEncodingInvalid:
return false;
case eEncodingUint:
if (byte_size > sizeof(unsigned long long))
Value::ValueType value_type = m_value.GetValueType();
if (value_type == Value::eValueTypeScalar)
{
// If the value is already a scalar, then let the scalar change itself:
m_value.GetScalar().SetValueFromCString (value_str, encoding, byte_size);
}
else if (byte_size <= Scalar::GetMaxByteSize())
{
// If the value fits in a scalar, then make a new scalar and again let the
// scalar code do the conversion, then figure out where to put the new value.
Scalar new_scalar;
Error error;
error = new_scalar.SetValueFromCString (value_str, encoding, byte_size);
if (error.Success())
{
return false;
}
else
{
unsigned long long ull_val = strtoull(value_str, &end, 0);
if (end && *end != '\0')
return false;
Value::ValueType value_type = m_value.GetValueType();
switch (value_type)
{
case Value::eValueTypeLoadAddress:
case Value::eValueTypeHostAddress:
// The value in these cases lives in the data. So update the data:
case Value::eValueTypeLoadAddress:
{
// If it is a load address, then the scalar value is the storage location
// of the data, and we have to shove this value down to that load location.
ProcessSP process_sp = GetUpdatePoint().GetProcessSP();
if (process_sp)
{
lldb::addr_t target_addr = m_value.GetScalar().GetRawBits64(LLDB_INVALID_ADDRESS);
size_t bytes_written = process_sp->WriteScalarToMemory (target_addr,
new_scalar,
byte_size,
error);
if (!error.Success() || bytes_written != byte_size)
return false;
}
}
break;
case Value::eValueTypeScalar:
m_value.GetScalar() = ull_val;
break;
case Value::eValueTypeFileAddress:
// Try to convert the file address to a load address and then write the new value there.
case Value::eValueTypeHostAddress:
{
// If it is a host address, then we stuff the scalar as a DataBuffer into the Value's data.
DataExtractor new_data;
new_data.SetByteOrder (m_data.GetByteOrder());
DataBufferSP buffer_sp (new DataBufferHeap(byte_size, 0));
m_data.SetData(buffer_sp, 0);
bool success = new_scalar.GetData(new_data);
if (success)
{
new_data.CopyByteOrderedData(0,
byte_size,
const_cast<uint8_t *>(m_data.GetDataStart()),
byte_size,
m_data.GetByteOrder());
}
m_value.GetScalar() = (uintptr_t)m_data.GetDataStart();
}
break;
case Value::eValueTypeFileAddress:
case Value::eValueTypeScalar:
break;
}
// Limit the bytes in our m_data appropriately.
m_value.GetScalar().GetData (m_data, byte_size);
}
break;
case eEncodingSint:
if (byte_size > sizeof(long long))
{
return false;
}
else
{
long long sll_val = strtoll(value_str, &end, 0);
if (end && *end != '\0')
return false;
m_value.GetScalar() = sll_val;
// Limit the bytes in our m_data appropriately.
m_value.GetScalar().GetData (m_data, byte_size);
return false;
}
break;
case eEncodingIEEE754:
{
const off_t byte_offset = GetByteOffset();
uint8_t *dst = const_cast<uint8_t *>(m_data.PeekData(byte_offset, byte_size));
if (dst != NULL)
{
// We are decoding a float into host byte order below, so make
// sure m_data knows what it contains.
m_data.SetByteOrder(lldb::endian::InlHostByteOrder());
const size_t converted_byte_size = ClangASTContext::ConvertStringToFloatValue (
GetClangAST(),
GetClangType(),
value_str,
dst,
byte_size);
if (converted_byte_size == byte_size)
{
}
}
}
break;
case eEncodingVector:
return false;
default:
}
else
{
// We don't support setting things bigger than a scalar at present.
return false;
}
// If we have made it here the value is in m_data and we should write it
// out to the target
return Write ();
}
bool
ValueObject::Write ()
{
// Clear the update ID so the next time we try and read the value
// we try and read it again.
m_update_point.SetNeedsUpdate();
// TODO: when Value has a method to write a value back, call it from here.
return false;
// If we have reached this point, then we have successfully changed the value.
SetNeedsUpdate();
return true;
}
lldb::LanguageType

2
lldb/source/Core/ValueObjectChild.cpp
View File

@ -150,7 +150,7 @@ ValueObjectChild::UpdateValue ()
else
{
// Set this object's scalar value to the address of its
// value be adding its byte offset to the parent address
// value by adding its byte offset to the parent address
m_value.GetScalar() += GetByteOffset();
}
}

18
lldb/source/Core/ValueObjectRegister.cpp
View File

@ -385,4 +385,22 @@ ValueObjectRegister::UpdateValue ()
return false;
}
bool
ValueObjectRegister::SetValueFromCString (const char *value_str)
{
// The new value will be in the m_data. Copy that into our register value.
Error error = m_reg_value.SetValueFromCString (&m_reg_info, value_str);
if (error.Success())
{
if (m_reg_ctx_sp->WriteRegister (&m_reg_info, m_reg_value))
{
SetNeedsUpdate();
return true;
}
else
return false;
}
else
return false;
}

31
lldb/source/Interpreter/CommandInterpreter.cpp
View File

@ -68,6 +68,7 @@ CommandInterpreter::CommandInterpreter
m_debugger (debugger),
m_synchronous_execution (synchronous_execution),
m_skip_lldbinit_files (false),
m_skip_app_init_files (false),
m_script_interpreter_ap (),
m_comment_char ('#'),
m_repeat_char ('!'),
@ -1762,11 +1763,37 @@ void
CommandInterpreter::SourceInitFile (bool in_cwd, CommandReturnObject &result)
{
// Don't parse any .lldbinit files if we were asked not to
if (m_skip_lldbinit_files)
if (m_skip_lldbinit_files && m_skip_app_init_files)
return;
const char *init_file_path = in_cwd ? "./.lldbinit" : "~/.lldbinit";
FileSpec init_file (init_file_path, true);
std::string app_specific_init;
if (!m_skip_app_init_files)
{
FileSpec host_spec = Host::GetProgramFileSpec();
const char *host_name = host_spec.GetFilename().AsCString();
if (host_name != NULL && strcmp (host_name, "lldb") != 0)
{
app_specific_init += init_file_path;
app_specific_init += "-";
app_specific_init += host_name;
}
}
FileSpec init_file;
if (!app_specific_init.empty())
{
init_file.SetFile (app_specific_init.c_str(), true);
}
if (!m_skip_lldbinit_files && !init_file.Exists())
{
init_file.SetFile (init_file_path, true);
}
// If the file exists, tell HandleCommand to 'source' it; this will do the actual broadcasting
// of the commands back to any appropriate listener (see CommandObjectSource::Execute for more details).

4
lldb/source/Target/ThreadPlanCallFunction.cpp
View File

@ -45,6 +45,7 @@ ThreadPlanCallFunction::ThreadPlanCallFunction (Thread &thread,
ThreadPlan (ThreadPlan::eKindCallFunction, "Call function plan", thread, eVoteNoOpinion, eVoteNoOpinion),
m_valid (false),
m_stop_other_threads (stop_other_threads),
m_function_addr (function),
m_function_sp (NULL),
m_process (thread.GetProcess()),
m_thread (thread),
@ -108,7 +109,6 @@ ThreadPlanCallFunction::ThreadPlanCallFunction (Thread &thread,
// Now set the thread state to "no reason" so we don't run with whatever signal was outstanding...
thread.SetStopInfoToNothing();
m_function_addr = function;
addr_t FunctionLoadAddr = m_function_addr.GetLoadAddress(&target);
if (this_arg && cmd_arg)
@ -161,6 +161,7 @@ ThreadPlanCallFunction::ThreadPlanCallFunction (Thread &thread,
ThreadPlan (ThreadPlan::eKindCallFunction, "Call function plan", thread, eVoteNoOpinion, eVoteNoOpinion),
m_valid (false),
m_stop_other_threads (stop_other_threads),
m_function_addr (function),
m_function_sp(NULL),
m_process (thread.GetProcess()),
m_thread (thread),
@ -224,7 +225,6 @@ ThreadPlanCallFunction::ThreadPlanCallFunction (Thread &thread,
// Now set the thread state to "no reason" so we don't run with whatever signal was outstanding...
thread.SetStopInfoToNothing();
m_function_addr = function;
addr_t FunctionLoadAddr = m_function_addr.GetLoadAddress(&target);
if (!abi->PrepareTrivialCall (thread,