aboutsummaryrefslogtreecommitdiff
path: root/source/Utility/Stream.cpp
diff options
context:
space:
mode:
Diffstat (limited to 'source/Utility/Stream.cpp')
-rw-r--r--source/Utility/Stream.cpp140
1 files changed, 60 insertions, 80 deletions
diff --git a/source/Utility/Stream.cpp b/source/Utility/Stream.cpp
index 7df7f7008084..54691c7066db 100644
--- a/source/Utility/Stream.cpp
+++ b/source/Utility/Stream.cpp
@@ -11,7 +11,8 @@
#include "lldb/Utility/Endian.h"
#include "lldb/Utility/VASPrintf.h"
-#include "llvm/ADT/SmallString.h" // for SmallString
+#include "llvm/ADT/SmallString.h"
+#include "llvm/Support/LEB128.h"
#include <string>
@@ -23,11 +24,11 @@ using namespace lldb_private;
Stream::Stream(uint32_t flags, uint32_t addr_size, ByteOrder byte_order)
: m_flags(flags), m_addr_size(addr_size), m_byte_order(byte_order),
- m_indent_level(0) {}
+ m_indent_level(0), m_forwarder(*this) {}
Stream::Stream()
: m_flags(0), m_addr_size(4), m_byte_order(endian::InlHostByteOrder()),
- m_indent_level(0) {}
+ m_indent_level(0), m_forwarder(*this) {}
//------------------------------------------------------------------
// Destructor
@@ -49,47 +50,20 @@ void Stream::Offset(uint32_t uval, const char *format) { Printf(format, uval); }
// Put an SLEB128 "uval" out to the stream using the printf format in "format".
//------------------------------------------------------------------
size_t Stream::PutSLEB128(int64_t sval) {
- size_t bytes_written = 0;
- if (m_flags.Test(eBinary)) {
- bool more = true;
- while (more) {
- uint8_t byte = sval & 0x7fu;
- sval >>= 7;
- /* sign bit of byte is 2nd high order bit (0x40) */
- if ((sval == 0 && !(byte & 0x40)) || (sval == -1 && (byte & 0x40)))
- more = false;
- else
- // more bytes to come
- byte |= 0x80u;
- bytes_written += Write(&byte, 1);
- }
- } else {
- bytes_written = Printf("0x%" PRIi64, sval);
- }
-
- return bytes_written;
+ if (m_flags.Test(eBinary))
+ return llvm::encodeSLEB128(sval, m_forwarder);
+ else
+ return Printf("0x%" PRIi64, sval);
}
//------------------------------------------------------------------
// Put an ULEB128 "uval" out to the stream using the printf format in "format".
//------------------------------------------------------------------
size_t Stream::PutULEB128(uint64_t uval) {
- size_t bytes_written = 0;
- if (m_flags.Test(eBinary)) {
- do {
-
- uint8_t byte = uval & 0x7fu;
- uval >>= 7;
- if (uval != 0) {
- // more bytes to come
- byte |= 0x80u;
- }
- bytes_written += Write(&byte, 1);
- } while (uval != 0);
- } else {
- bytes_written = Printf("0x%" PRIx64, uval);
- }
- return bytes_written;
+ if (m_flags.Test(eBinary))
+ return llvm::encodeULEB128(uval, m_forwarder);
+ else
+ return Printf("0x%" PRIx64, uval);
}
//------------------------------------------------------------------
@@ -119,9 +93,9 @@ void Stream::QuotedCString(const char *cstr, const char *format) {
//------------------------------------------------------------------
void Stream::Address(uint64_t addr, uint32_t addr_size, const char *prefix,
const char *suffix) {
- if (prefix == NULL)
+ if (prefix == nullptr)
prefix = "";
- if (suffix == NULL)
+ if (suffix == nullptr)
suffix = "";
// int addr_width = m_addr_size << 1;
// Printf ("%s0x%0*" PRIx64 "%s", prefix, addr_width, addr, suffix);
@@ -339,26 +313,25 @@ size_t Stream::PrintfAsRawHex8(const char *format, ...) {
llvm::SmallString<1024> buf;
VASprintf(buf, format, args);
- size_t length = 0;
+ ByteDelta delta(*this);
for (char C : buf)
- length += _PutHex8(C, false);
+ _PutHex8(C, false);
va_end(args);
- return length;
+ return *delta;
}
size_t Stream::PutNHex8(size_t n, uint8_t uvalue) {
- size_t bytes_written = 0;
+ ByteDelta delta(*this);
for (size_t i = 0; i < n; ++i)
- bytes_written += _PutHex8(uvalue, false);
- return bytes_written;
+ _PutHex8(uvalue, false);
+ return *delta;
}
-size_t Stream::_PutHex8(uint8_t uvalue, bool add_prefix) {
- size_t bytes_written = 0;
+void Stream::_PutHex8(uint8_t uvalue, bool add_prefix) {
if (m_flags.Test(eBinary)) {
- bytes_written = Write(&uvalue, 1);
+ Write(&uvalue, 1);
} else {
if (add_prefix)
PutCString("0x");
@@ -369,56 +342,62 @@ size_t Stream::_PutHex8(uint8_t uvalue, bool add_prefix) {
char nibble_chars[2];
nibble_chars[0] = g_hex_to_ascii_hex_char[(uvalue >> 4) & 0xf];
nibble_chars[1] = g_hex_to_ascii_hex_char[(uvalue >> 0) & 0xf];
- bytes_written = Write(nibble_chars, sizeof(nibble_chars));
+ Write(nibble_chars, sizeof(nibble_chars));
}
- return bytes_written;
}
-size_t Stream::PutHex8(uint8_t uvalue) { return _PutHex8(uvalue, false); }
+size_t Stream::PutHex8(uint8_t uvalue) {
+ ByteDelta delta(*this);
+ _PutHex8(uvalue, false);
+ return *delta;
+}
size_t Stream::PutHex16(uint16_t uvalue, ByteOrder byte_order) {
+ ByteDelta delta(*this);
+
if (byte_order == eByteOrderInvalid)
byte_order = m_byte_order;
- size_t bytes_written = 0;
if (byte_order == eByteOrderLittle) {
for (size_t byte = 0; byte < sizeof(uvalue); ++byte)
- bytes_written += _PutHex8((uint8_t)(uvalue >> (byte * 8)), false);
+ _PutHex8((uint8_t)(uvalue >> (byte * 8)), false);
} else {
for (size_t byte = sizeof(uvalue) - 1; byte < sizeof(uvalue); --byte)
- bytes_written += _PutHex8((uint8_t)(uvalue >> (byte * 8)), false);
+ _PutHex8((uint8_t)(uvalue >> (byte * 8)), false);
}
- return bytes_written;
+ return *delta;
}
size_t Stream::PutHex32(uint32_t uvalue, ByteOrder byte_order) {
+ ByteDelta delta(*this);
+
if (byte_order == eByteOrderInvalid)
byte_order = m_byte_order;
- size_t bytes_written = 0;
if (byte_order == eByteOrderLittle) {
for (size_t byte = 0; byte < sizeof(uvalue); ++byte)
- bytes_written += _PutHex8((uint8_t)(uvalue >> (byte * 8)), false);
+ _PutHex8((uint8_t)(uvalue >> (byte * 8)), false);
} else {
for (size_t byte = sizeof(uvalue) - 1; byte < sizeof(uvalue); --byte)
- bytes_written += _PutHex8((uint8_t)(uvalue >> (byte * 8)), false);
+ _PutHex8((uint8_t)(uvalue >> (byte * 8)), false);
}
- return bytes_written;
+ return *delta;
}
size_t Stream::PutHex64(uint64_t uvalue, ByteOrder byte_order) {
+ ByteDelta delta(*this);
+
if (byte_order == eByteOrderInvalid)
byte_order = m_byte_order;
- size_t bytes_written = 0;
if (byte_order == eByteOrderLittle) {
for (size_t byte = 0; byte < sizeof(uvalue); ++byte)
- bytes_written += _PutHex8((uint8_t)(uvalue >> (byte * 8)), false);
+ _PutHex8((uint8_t)(uvalue >> (byte * 8)), false);
} else {
for (size_t byte = sizeof(uvalue) - 1; byte < sizeof(uvalue); --byte)
- bytes_written += _PutHex8((uint8_t)(uvalue >> (byte * 8)), false);
+ _PutHex8((uint8_t)(uvalue >> (byte * 8)), false);
}
- return bytes_written;
+ return *delta;
}
size_t Stream::PutMaxHex64(uint64_t uvalue, size_t byte_size,
@@ -427,11 +406,11 @@ size_t Stream::PutMaxHex64(uint64_t uvalue, size_t byte_size,
case 1:
return PutHex8((uint8_t)uvalue);
case 2:
- return PutHex16((uint16_t)uvalue);
+ return PutHex16((uint16_t)uvalue, byte_order);
case 4:
- return PutHex32((uint32_t)uvalue);
+ return PutHex32((uint32_t)uvalue, byte_order);
case 8:
- return PutHex64(uvalue);
+ return PutHex64(uvalue, byte_order);
}
return 0;
}
@@ -464,65 +443,66 @@ size_t Stream::PutLongDouble(long double ld, ByteOrder byte_order) {
size_t Stream::PutRawBytes(const void *s, size_t src_len,
ByteOrder src_byte_order, ByteOrder dst_byte_order) {
+ ByteDelta delta(*this);
+
if (src_byte_order == eByteOrderInvalid)
src_byte_order = m_byte_order;
if (dst_byte_order == eByteOrderInvalid)
dst_byte_order = m_byte_order;
- size_t bytes_written = 0;
const uint8_t *src = (const uint8_t *)s;
bool binary_was_set = m_flags.Test(eBinary);
if (!binary_was_set)
m_flags.Set(eBinary);
if (src_byte_order == dst_byte_order) {
for (size_t i = 0; i < src_len; ++i)
- bytes_written += _PutHex8(src[i], false);
+ _PutHex8(src[i], false);
} else {
for (size_t i = src_len - 1; i < src_len; --i)
- bytes_written += _PutHex8(src[i], false);
+ _PutHex8(src[i], false);
}
if (!binary_was_set)
m_flags.Clear(eBinary);
- return bytes_written;
+ return *delta;
}
size_t Stream::PutBytesAsRawHex8(const void *s, size_t src_len,
ByteOrder src_byte_order,
ByteOrder dst_byte_order) {
+ ByteDelta delta(*this);
if (src_byte_order == eByteOrderInvalid)
src_byte_order = m_byte_order;
if (dst_byte_order == eByteOrderInvalid)
dst_byte_order = m_byte_order;
- size_t bytes_written = 0;
const uint8_t *src = (const uint8_t *)s;
bool binary_is_set = m_flags.Test(eBinary);
m_flags.Clear(eBinary);
if (src_byte_order == dst_byte_order) {
for (size_t i = 0; i < src_len; ++i)
- bytes_written += _PutHex8(src[i], false);
+ _PutHex8(src[i], false);
} else {
for (size_t i = src_len - 1; i < src_len; --i)
- bytes_written += _PutHex8(src[i], false);
+ _PutHex8(src[i], false);
}
if (binary_is_set)
m_flags.Set(eBinary);
- return bytes_written;
+ return *delta;
}
size_t Stream::PutCStringAsRawHex8(const char *s) {
- size_t bytes_written = 0;
+ ByteDelta delta(*this);
bool binary_is_set = m_flags.Test(eBinary);
m_flags.Clear(eBinary);
- do {
- bytes_written += _PutHex8(*s, false);
+ while(*s) {
+ _PutHex8(*s, false);
++s;
- } while (*s);
+ }
if (binary_is_set)
m_flags.Set(eBinary);
- return bytes_written;
+ return *delta;
}
generated by cgit v1.2.3 (git 2.25.1) at 2025-11-07 06:35:13 +0000