Added new lldb_private::Process memory read/write functions to stop a bunch

of duplicated code from appearing all over LLDB:

lldb::addr_t
Process::ReadPointerFromMemory (lldb::addr_t vm_addr, Error &error);

bool
Process::WritePointerToMemory (lldb::addr_t vm_addr, lldb::addr_t ptr_value, Error &error);

size_t
Process::ReadScalarIntegerFromMemory (lldb::addr_t addr, uint32_t byte_size, bool is_signed, Scalar &scalar, Error &error);

size_t
Process::WriteScalarToMemory (lldb::addr_t vm_addr, const Scalar &scalar, uint32_t size, Error &error);

in lldb_private::Process the following functions were renamed:

From:
uint64_t
Process::ReadUnsignedInteger (lldb::addr_t load_addr, 
                              size_t byte_size,
                              Error &error);

To:
uint64_t
Process::ReadUnsignedIntegerFromMemory (lldb::addr_t load_addr, 
                                        size_t byte_size,
                                        uint64_t fail_value, 
                                        Error &error);

Cleaned up a lot of code that was manually doing what the above functions do
to use the functions listed above.

Added the ability to get a scalar value as a buffer that can be written down
to a process (byte swapping the Scalar value if needed):

uint32_t 
Scalar::GetAsMemoryData (void *dst,
                        uint32_t dst_len, 
                        lldb::ByteOrder dst_byte_order,
                        Error &error) const;

The "dst_len" can be smaller that the size of the scalar and the least 
significant bytes will be written. "dst_len" can also be larger and the
most significant bytes will be padded with zeroes. 

Centralized the code that adds or removes address bits for callable and opcode
addresses into lldb_private::Target:

lldb::addr_t
Target::GetCallableLoadAddress (lldb::addr_t load_addr, AddressClass addr_class) const;

lldb::addr_t
Target::GetOpcodeLoadAddress (lldb::addr_t load_addr, AddressClass addr_class) const;

All necessary lldb_private::Address functions now use the target versions so
changes should only need to happen in one place if anything needs updating.

Fixed up a lot of places that were calling :

addr_t
Address::GetLoadAddress(Target*);

to call the Address::GetCallableLoadAddress() or Address::GetOpcodeLoadAddress()
as needed. There were many places in the breakpoint code where things could
go wrong for ARM if these weren't used.

llvm-svn: 131878

1 files changed, 4 insertions, 22 deletions

diff --git a/lldb/source/Plugins/ABI/MacOSX-arm/ABIMacOSX_arm.cpp b/lldb/source/Plugins/ABI/MacOSX-arm/ABIMacOSX_arm.cpp
index d7a609166d1..09be5fda016 100644
--- a/lldb/source/Plugins/ABI/MacOSX-arm/ABIMacOSX_arm.cpp
+++ b/lldb/source/Plugins/ABI/MacOSX-arm/ABIMacOSX_arm.cpp
@@ -269,29 +269,11 @@ ABIMacOSX_arm::GetArgumentValues (Thread &thread,
                 {
                     // Arguments 5 on up are on the stack
                     const uint32_t arg_byte_size = (bit_width + (8-1)) / 8;
-                    if (arg_byte_size <= sizeof(uint64_t))
-                    {
-                        uint8_t arg_data[sizeof(uint64_t)];
-                        Error error;
-                        thread.GetProcess().ReadMemory(sp, arg_data, sizeof(arg_data), error);
-                        DataExtractor arg_data_extractor (arg_data, sizeof(arg_data), 
-                                                          thread.GetProcess().GetTarget().GetArchitecture().GetByteOrder(), 
-                                                          thread.GetProcess().GetTarget().GetArchitecture().GetAddressByteSize());
-                        uint32_t offset = 0;
-                        if (arg_byte_size <= 4)
-                            value->GetScalar() = arg_data_extractor.GetMaxU32 (&offset, arg_byte_size);
-                        else if (arg_byte_size <= 8)
-                            value->GetScalar() = arg_data_extractor.GetMaxU64 (&offset, arg_byte_size);
-                        else
-                            return false;
-
-                        if (offset == 0 || offset == UINT32_MAX)
-                            return false;
+                    Error error;
+                    if (!thread.GetProcess().ReadScalarIntegerFromMemory(sp, arg_byte_size, is_signed, value->GetScalar(), error))
+                        return false;
 
-                        if (is_signed)
-                            value->GetScalar().SignExtend (bit_width);
-                        sp += arg_byte_size;
-                    }
+                    sp += arg_byte_size;
                 }
             }
         }