Make lldb::endian::InlHostByteOrder() private.

[brucem]

Summary

Since this is within the lldb namespace, the compiler tries to
export a symbol for it. Unfortunately, since it is inlined, the
symbol is hidden and this results in a mess of warnings when
building on OS X with cmake.

Moving it to the lldb_private namespace eliminates that problem.

lldb/trunk/include/lldb/Core/Opcode.h

protected:
         }
 
         lldb::ByteOrder
         GetDataByteOrder () const;
 
         bool
         GetEndianSwap() const
         {
-            return (m_byte_order == lldb::eByteOrderBig && lldb::endian::InlHostByteOrder() == lldb::eByteOrderLittle) ||
-                   (m_byte_order == lldb::eByteOrderLittle && lldb::endian::InlHostByteOrder() == lldb::eByteOrderBig);
+            return (m_byte_order == lldb::eByteOrderBig && endian::InlHostByteOrder() == lldb::eByteOrderLittle) ||
+                   (m_byte_order == lldb::eByteOrderLittle && endian::InlHostByteOrder() == lldb::eByteOrderBig);
         }
 
         lldb::ByteOrder m_byte_order;
 
         Opcode::Type m_type;
         union
         {
             uint8_t inst8;

lldb/trunk/include/lldb/Core/RegisterValue.h

public:
         const void *
         GetBytes () const;
 
         lldb::ByteOrder
         GetByteOrder () const
         {
             if (m_type == eTypeBytes)
                 return buffer.byte_order;
-            return lldb::endian::InlHostByteOrder();
+            return endian::InlHostByteOrder();
         }
         
         uint32_t
         GetByteSize () const;
 
         static uint32_t
         GetMaxByteSize ()
         {

lldb/trunk/include/lldb/Host/Endian.h

 //===-- Endian.h ------------------------------------------------*- C++ -*-===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef liblldb_host_endian_h_
 #define liblldb_host_endian_h_
 
 #include "lldb/lldb-enumerations.h"
 
-namespace lldb {
+namespace lldb_private {
 
 namespace endian {
 
     static union EndianTest
     {
         uint32_t num;
         uint8_t  bytes[sizeof(uint32_t)];
     } const endianTest = { 0x01020304 };
     
-    inline ByteOrder InlHostByteOrder() { return (ByteOrder)endianTest.bytes[0]; }
+    inline lldb::ByteOrder InlHostByteOrder() { return (lldb::ByteOrder)endianTest.bytes[0]; }
 
 //    ByteOrder const InlHostByteOrder = (ByteOrder)endianTest.bytes[0];
 }
 
 }
 
 #endif  // liblldb_host_endian_h_
 

lldb/trunk/source/Core/Address.cpp

 {
     if (exe_scope == NULL)
         return 0;
     const size_t k_buf_len = 256;
     char buf[k_buf_len+1];
     buf[k_buf_len] = '\0'; // NULL terminate
 
     // Byte order and address size don't matter for C string dumping..
-    DataExtractor data (buf, sizeof(buf), lldb::endian::InlHostByteOrder(), 4);
+    DataExtractor data (buf, sizeof(buf), endian::InlHostByteOrder(), 4);
     size_t total_len = 0;
     size_t bytes_read;
     Address curr_address(address);
     strm->PutChar ('"');
     while ((bytes_read = ReadBytes (exe_scope, curr_address, buf, k_buf_len)) > 0)
     {
         size_t len = strlen(buf);
         if (len == 0)

lldb/trunk/source/Core/DataEncoder.cpp

 }
 
 //----------------------------------------------------------------------
 // Default constructor.
 //----------------------------------------------------------------------
 DataEncoder::DataEncoder () :
     m_start     (NULL),
     m_end       (NULL),
-    m_byte_order(lldb::endian::InlHostByteOrder()),
+    m_byte_order(endian::InlHostByteOrder()),
     m_addr_size (sizeof(void*)),
     m_data_sp   ()
 {
 }
 
 //----------------------------------------------------------------------
 // This constructor allows us to use data that is owned by someone else.
 // The data must stay around as long as this object is valid.

 // release any references to shared data that this object may
 // contain.
 //------------------------------------------------------------------
 void
 DataEncoder::Clear ()
 {
     m_start = NULL;
     m_end = NULL;
-    m_byte_order = lldb::endian::InlHostByteOrder();
+    m_byte_order = endian::InlHostByteOrder();
     m_addr_size = sizeof(void*);
     m_data_sp.reset();
 }
 
 //------------------------------------------------------------------
 // If this object contains shared data, this function returns the
 // offset into that shared data. Else zero is returned.
 //------------------------------------------------------------------
DataEncoder::PutU8 (uint32_t offset, uint8_t value)
     return UINT32_MAX;
 }
 
 uint32_t
 DataEncoder::PutU16 (uint32_t offset, uint16_t value)
 {
     if (ValidOffsetForDataOfSize(offset, sizeof(value)))
     {
-        if (m_byte_order != lldb::endian::InlHostByteOrder())
+        if (m_byte_order != endian::InlHostByteOrder())
             WriteSwappedInt16 (m_start, offset, value);
         else
             WriteInt16 (m_start, offset, value);
 
         return offset + sizeof (value);
     }
     return UINT32_MAX;
 }
 
 uint32_t
 DataEncoder::PutU32 (uint32_t offset, uint32_t value)
 {
     if (ValidOffsetForDataOfSize(offset, sizeof(value)))
     {
-        if (m_byte_order != lldb::endian::InlHostByteOrder())
+        if (m_byte_order != endian::InlHostByteOrder())
             WriteSwappedInt32 (m_start, offset, value);
         else
             WriteInt32 (m_start, offset, value);
         
         return offset + sizeof (value);
     }
     return UINT32_MAX;
 }
 
 uint32_t
 DataEncoder::PutU64 (uint32_t offset, uint64_t value)
 {
     if (ValidOffsetForDataOfSize(offset, sizeof(value)))
     {
-        if (m_byte_order != lldb::endian::InlHostByteOrder())
+        if (m_byte_order != endian::InlHostByteOrder())
             WriteSwappedInt64 (m_start, offset, value);
         else
             WriteInt64 (m_start, offset, value);
         
         return offset + sizeof (value);
     }
     return UINT32_MAX;
 }

lldb/trunk/source/Core/DataExtractor.cpp

 
 #define NON_PRINTABLE_CHAR '.'
 //----------------------------------------------------------------------
 // Default constructor.
 //----------------------------------------------------------------------
 DataExtractor::DataExtractor () :
     m_start     (NULL),
     m_end       (NULL),
-    m_byte_order(lldb::endian::InlHostByteOrder()),
+    m_byte_order(endian::InlHostByteOrder()),
     m_addr_size (sizeof(void *)),
     m_data_sp   (),
     m_target_byte_size(1)
 {
 }
 
 //----------------------------------------------------------------------
 // This constructor allows us to use data that is owned by someone else.

 // release any references to shared data that this object may
 // contain.
 //------------------------------------------------------------------
 void
 DataExtractor::Clear ()
 {
     m_start = NULL;
     m_end = NULL;
-    m_byte_order = lldb::endian::InlHostByteOrder();
+    m_byte_order = endian::InlHostByteOrder();
     m_addr_size = sizeof(void *);
     m_data_sp.reset();
 }
 
 //------------------------------------------------------------------
 // If this object contains shared data, this function returns the
 // offset into that shared data. Else zero is returned.
 //------------------------------------------------------------------

 //----------------------------------------------------------------------
 uint16_t
 DataExtractor::GetU16 (offset_t *offset_ptr) const
 {
     uint16_t val = 0;
     const uint8_t *data = (const uint8_t *)GetData (offset_ptr, sizeof(val));
     if (data)
     {
-        if (m_byte_order != lldb::endian::InlHostByteOrder())
+        if (m_byte_order != endian::InlHostByteOrder())
             val = ReadSwapInt16(data);
         else
             val = ReadInt16 (data);
     }
     return val;
 }
 
 uint16_t
 DataExtractor::GetU16_unchecked (offset_t *offset_ptr) const
 {
     uint16_t val;
-    if (m_byte_order == lldb::endian::InlHostByteOrder())
+    if (m_byte_order == endian::InlHostByteOrder())
         val = ReadInt16 (m_start, *offset_ptr);
     else
         val = ReadSwapInt16(m_start, *offset_ptr);
     *offset_ptr += sizeof(val);
     return val;
 }
 
 uint32_t
 DataExtractor::GetU32_unchecked (offset_t *offset_ptr) const
 {
     uint32_t val;
-    if (m_byte_order == lldb::endian::InlHostByteOrder())
+    if (m_byte_order == endian::InlHostByteOrder())
         val = ReadInt32 (m_start, *offset_ptr);
     else
         val =  ReadSwapInt32 (m_start, *offset_ptr);
     *offset_ptr += sizeof(val);
     return val;
 }
 
 uint64_t
 DataExtractor::GetU64_unchecked (offset_t *offset_ptr) const
 {
     uint64_t val;
-    if (m_byte_order == lldb::endian::InlHostByteOrder())
+    if (m_byte_order == endian::InlHostByteOrder())
         val = ReadInt64 (m_start, *offset_ptr);
     else
         val = ReadSwapInt64 (m_start, *offset_ptr);
     *offset_ptr += sizeof(val);
     return val;
 }
 
 
 //----------------------------------------------------------------------
 // Extract "count" uint16_t values from the binary data and update
 // the offset pointed to by "offset_ptr". The extracted data is
 // copied into "dst".
 //
 // RETURNS the non-NULL buffer pointer upon successful extraction of
 // all the requested bytes, or NULL when the data is not available
 // in the buffer due to being out of bounds, or insufficient data.
 //----------------------------------------------------------------------
 void *
 DataExtractor::GetU16 (offset_t *offset_ptr, void *void_dst, uint32_t count) const
 {
     const size_t src_size = sizeof(uint16_t) * count;
     const uint16_t *src = (const uint16_t *)GetData (offset_ptr, src_size);
     if (src)
     {
-        if (m_byte_order != lldb::endian::InlHostByteOrder())
+        if (m_byte_order != endian::InlHostByteOrder())
         {
             uint16_t *dst_pos = (uint16_t *)void_dst;
             uint16_t *dst_end = dst_pos + count;
             const uint16_t *src_pos = src;
             while (dst_pos < dst_end)
             {
                 *dst_pos = ReadSwapInt16 (src_pos);
                 ++dst_pos;

 //----------------------------------------------------------------------
 uint32_t
 DataExtractor::GetU32 (offset_t *offset_ptr) const
 {
     uint32_t val = 0;
     const uint8_t *data = (const uint8_t *)GetData (offset_ptr, sizeof(val));
     if (data)
     {
-        if (m_byte_order != lldb::endian::InlHostByteOrder())
+        if (m_byte_order != endian::InlHostByteOrder())
         {
             val = ReadSwapInt32 (data);
         }
         else
         {
             memcpy (&val, data, 4);
         }
     }

 //----------------------------------------------------------------------
 void *
 DataExtractor::GetU32 (offset_t *offset_ptr, void *void_dst, uint32_t count) const
 {
     const size_t src_size = sizeof(uint32_t) * count;
     const uint32_t *src = (const uint32_t *)GetData (offset_ptr, src_size);
     if (src)
     {
-        if (m_byte_order != lldb::endian::InlHostByteOrder())
+        if (m_byte_order != endian::InlHostByteOrder())
         {
             uint32_t *dst_pos = (uint32_t *)void_dst;
             uint32_t *dst_end = dst_pos + count;
             const uint32_t *src_pos = src;
             while (dst_pos < dst_end)
             {
                 *dst_pos = ReadSwapInt32 (src_pos);
                 ++dst_pos;

 //----------------------------------------------------------------------
 uint64_t
 DataExtractor::GetU64 (offset_t *offset_ptr) const
 {
     uint64_t val = 0;
     const uint8_t *data = (const uint8_t *)GetData (offset_ptr, sizeof(val));
     if (data)
     {
-        if (m_byte_order != lldb::endian::InlHostByteOrder())
+        if (m_byte_order != endian::InlHostByteOrder())
         {
             val = ReadSwapInt64 (data);
         }
         else
         {
             memcpy (&val, data, 8);
         }
     }

 //----------------------------------------------------------------------
 void *
 DataExtractor::GetU64 (offset_t *offset_ptr, void *void_dst, uint32_t count) const
 {
     const size_t src_size = sizeof(uint64_t) * count;
     const uint64_t *src = (const uint64_t *)GetData (offset_ptr, src_size);
     if (src)
     {
-        if (m_byte_order != lldb::endian::InlHostByteOrder())
+        if (m_byte_order != endian::InlHostByteOrder())
         {
             uint64_t *dst_pos = (uint64_t *)void_dst;
             uint64_t *dst_end = dst_pos + count;
             const uint64_t *src_pos = src;
             while (dst_pos < dst_end)
             {
                 *dst_pos = ReadSwapInt64 (src_pos);
                 ++dst_pos;

 DataExtractor::GetFloat (offset_t *offset_ptr) const
 {
     typedef float float_type;
     float_type val = 0.0;
     const size_t src_size = sizeof(float_type);
     const float_type *src = (const float_type *)GetData (offset_ptr, src_size);
     if (src)
     {
-        if (m_byte_order != lldb::endian::InlHostByteOrder())
+        if (m_byte_order != endian::InlHostByteOrder())
         {
             const uint8_t *src_data = (const uint8_t *)src;
             uint8_t *dst_data = (uint8_t *)&val;
             for (size_t i=0; i<sizeof(float_type); ++i)
                 dst_data[sizeof(float_type) - 1 - i] = src_data[i];
         }
         else
         {
             val = *src;
         }
     }
     return val;
 }
 
 double
 DataExtractor::GetDouble (offset_t *offset_ptr) const
 {
     typedef double float_type;
     float_type val = 0.0;
     const size_t src_size = sizeof(float_type);
     const float_type *src = (const float_type *)GetData (offset_ptr, src_size);
     if (src)
     {
-        if (m_byte_order != lldb::endian::InlHostByteOrder())
+        if (m_byte_order != endian::InlHostByteOrder())
         {
             const uint8_t *src_data = (const uint8_t *)src;
             uint8_t *dst_data = (uint8_t *)&val;
             for (size_t i=0; i<sizeof(float_type); ++i)
                 dst_data[sizeof(float_type) - 1 - i] = src_data[i];
         }
         else
         {
             val = *src;
         }
     }
     return val;
 }
 
 
 long double
 DataExtractor::GetLongDouble (offset_t *offset_ptr) const
 {
     long double val = 0.0;
 #if defined (__i386__) || defined (__amd64__) || defined (__x86_64__) || defined(_M_IX86) || defined(_M_IA64) || defined(_M_X64)
-    *offset_ptr += CopyByteOrderedData (*offset_ptr, 10, &val, sizeof(val), lldb::endian::InlHostByteOrder());
+    *offset_ptr += CopyByteOrderedData (*offset_ptr, 10, &val, sizeof(val), endian::InlHostByteOrder());
 #else
-    *offset_ptr += CopyByteOrderedData (*offset_ptr, sizeof(val), &val, sizeof(val), lldb::endian::InlHostByteOrder());
+    *offset_ptr += CopyByteOrderedData (*offset_ptr, sizeof(val), &val, sizeof(val), endian::InlHostByteOrder());
 #endif
     return val;
 }
 
 
 //------------------------------------------------------------------
 // Extract a single address from the data and update the offset
 // pointed to by "offset_ptr". The size of the extracted address

lldb/trunk/source/Core/Event.cpp

EventDataBytes::Dump (Stream *s) const
     size_t num_printable_chars = std::count_if (m_bytes.begin(), m_bytes.end(), isprint);
     if (num_printable_chars == m_bytes.size())
     {
         s->Printf("\"%s\"", m_bytes.c_str());
     }
     else if (m_bytes.size() > 0)
     {
         DataExtractor data;
-        data.SetData(&m_bytes[0], m_bytes.size(), lldb::endian::InlHostByteOrder());
+        data.SetData(&m_bytes[0], m_bytes.size(), endian::InlHostByteOrder());
         data.Dump(s, 0, eFormatBytes, 1, m_bytes.size(), 32, LLDB_INVALID_ADDRESS, 0, 0);
     }
 }
 
 const void *
 EventDataBytes::GetBytes() const
 {
     if (m_bytes.empty())

lldb/trunk/source/Core/Opcode.cpp

Opcode::GetDataByteOrder () const
     }
     switch (m_type)
     {
         case Opcode::eTypeInvalid: break;
         case Opcode::eType8:
         case Opcode::eType16:
         case Opcode::eType16_2:
         case Opcode::eType32:
-        case Opcode::eType64:    return lldb::endian::InlHostByteOrder();
+        case Opcode::eType64:    return endian::InlHostByteOrder();
         case Opcode::eTypeBytes:
             break;
     }
     return eByteOrderInvalid;
 }
 
 uint32_t
 Opcode::GetData (DataExtractor &data) const

lldb/trunk/source/Core/Scalar.cpp

 {
     size_t byte_size = GetByteSize();
     static float f_val;
     static double d_val;
     if (byte_size > 0)
     {
         if (limit_byte_size < byte_size)
         {
-            if (lldb::endian::InlHostByteOrder() == eByteOrderLittle)
+            if (endian::InlHostByteOrder() == eByteOrderLittle)
             {
                 // On little endian systems if we want fewer bytes from the
                 // current type we just specify fewer bytes since the LSByte
                 // is first...
                 switch(m_type)
                 {
                 case e_void:
                     break;
                 case e_sint:
                 case e_uint:
                 case e_slong:
                 case e_ulong:
                 case e_slonglong:
                 case e_ulonglong:
                 case e_sint128:
                 case e_uint128:
-                    data.SetData((const uint8_t *)m_integer.getRawData(), limit_byte_size, lldb::endian::InlHostByteOrder());
+                    data.SetData((const uint8_t *)m_integer.getRawData(), limit_byte_size, endian::InlHostByteOrder());
                     return true;
                 case e_float:
                     f_val = m_float.convertToFloat();
-                    data.SetData((uint8_t *)&f_val, limit_byte_size, lldb::endian::InlHostByteOrder());
+                    data.SetData((uint8_t *)&f_val, limit_byte_size, endian::InlHostByteOrder());
                     return true;
                 case e_double:
                     d_val = m_float.convertToDouble();
-                    data.SetData((uint8_t *)&d_val, limit_byte_size, lldb::endian::InlHostByteOrder());
+                    data.SetData((uint8_t *)&d_val, limit_byte_size, endian::InlHostByteOrder());
                     return true;
                 case e_long_double:
                     static llvm::APInt ldbl_val = m_float.bitcastToAPInt();
-                    data.SetData((const uint8_t *)ldbl_val.getRawData(), limit_byte_size, lldb::endian::InlHostByteOrder());
+                    data.SetData((const uint8_t *)ldbl_val.getRawData(), limit_byte_size, endian::InlHostByteOrder());
                     return true;
                 }
             }
-            else if (lldb::endian::InlHostByteOrder() == eByteOrderBig)
+            else if (endian::InlHostByteOrder() == eByteOrderBig)
             {
                 // On big endian systems if we want fewer bytes from the
                 // current type have to advance our initial byte pointer and
                 // trim down the number of bytes since the MSByte is first
                 switch(m_type)
                 {
                 case e_void:
                     break;
                 case e_sint:
                 case e_uint:
                 case e_slong:
                 case e_ulong:
                 case e_slonglong:
                 case e_ulonglong:
                 case e_sint128:
                 case e_uint128:
-                    data.SetData((const uint8_t *)m_integer.getRawData() + byte_size - limit_byte_size, limit_byte_size, lldb::endian::InlHostByteOrder());
+                    data.SetData((const uint8_t *)m_integer.getRawData() + byte_size - limit_byte_size, limit_byte_size, endian::InlHostByteOrder());
                     return true;
                 case e_float:
                     f_val = m_float.convertToFloat();
-                    data.SetData((uint8_t *)&f_val + byte_size - limit_byte_size, limit_byte_size, lldb::endian::InlHostByteOrder());
+                    data.SetData((uint8_t *)&f_val + byte_size - limit_byte_size, limit_byte_size, endian::InlHostByteOrder());
                     return true;
                 case e_double:
                     d_val = m_float.convertToDouble();
-                    data.SetData((uint8_t *)&d_val + byte_size - limit_byte_size, limit_byte_size, lldb::endian::InlHostByteOrder());
+                    data.SetData((uint8_t *)&d_val + byte_size - limit_byte_size, limit_byte_size, endian::InlHostByteOrder());
                     return true;
                 case e_long_double:
                     static llvm::APInt ldbl_val = m_float.bitcastToAPInt();
-                    data.SetData((const uint8_t *)ldbl_val.getRawData() + byte_size - limit_byte_size, limit_byte_size, lldb::endian::InlHostByteOrder());
+                    data.SetData((const uint8_t *)ldbl_val.getRawData() + byte_size - limit_byte_size, limit_byte_size, endian::InlHostByteOrder());
                     return true;
                 }
             }
         }
         else
         {
             // We want all of the data
             switch(m_type)
             {
             case e_void:
                 break;
             case e_sint:
             case e_uint:
             case e_slong:
             case e_ulong:
             case e_slonglong:
             case e_ulonglong:
             case e_sint128:
             case e_uint128:
-                data.SetData((const uint8_t *)m_integer.getRawData(), byte_size, lldb::endian::InlHostByteOrder());
+                data.SetData((const uint8_t *)m_integer.getRawData(), byte_size, endian::InlHostByteOrder());
                 return true;
             case e_float:
                 f_val = m_float.convertToFloat();
-                data.SetData((uint8_t *)&f_val, byte_size, lldb::endian::InlHostByteOrder());
+                data.SetData((uint8_t *)&f_val, byte_size, endian::InlHostByteOrder());
                 return true;
             case e_double:
                 d_val = m_float.convertToDouble();
-                data.SetData((uint8_t *)&d_val, byte_size, lldb::endian::InlHostByteOrder());
+                data.SetData((uint8_t *)&d_val, byte_size, endian::InlHostByteOrder());
                 return true;
             case e_long_double:
                 static llvm::APInt ldbl_val = m_float.bitcastToAPInt();
-                data.SetData((const uint8_t *)ldbl_val.getRawData(), byte_size, lldb::endian::InlHostByteOrder());
+                data.SetData((const uint8_t *)ldbl_val.getRawData(), byte_size, endian::InlHostByteOrder());
                 return true;
             }
         }
         return true;
     }
     data.Clear();
     return false;
 }

lldb/trunk/source/Core/Stream.cpp

Stream::Stream (uint32_t flags, uint32_t addr_size, ByteOrder byte_order) :
     m_byte_order (byte_order),
     m_indent_level(0)
 {
 }
 
 Stream::Stream () :
     m_flags (0),
     m_addr_size (4),
-    m_byte_order (lldb::endian::InlHostByteOrder()),
+    m_byte_order (endian::InlHostByteOrder()),
     m_indent_level(0)
 {
 }
 
 //------------------------------------------------------------------
 // Destructor
 //------------------------------------------------------------------
 Stream::~Stream ()
)
     case 8: return PutHex64 (uvalue);
     }
     return 0;
 }
 
 size_t
 Stream::PutPointer (void *ptr)
 {
-    return PutRawBytes (&ptr, sizeof(ptr), lldb::endian::InlHostByteOrder(), lldb::endian::InlHostByteOrder());
+    return PutRawBytes (&ptr, sizeof(ptr), endian::InlHostByteOrder(), endian::InlHostByteOrder());
 }
 
 size_t
 Stream::PutFloat(float f, ByteOrder byte_order)
 {
     if (byte_order == eByteOrderInvalid)
         byte_order = m_byte_order;
 
-    return PutRawBytes (&f, sizeof(f), lldb::endian::InlHostByteOrder(), byte_order);
+    return PutRawBytes (&f, sizeof(f), endian::InlHostByteOrder(), byte_order);
 }
 
 size_t
 Stream::PutDouble(double d, ByteOrder byte_order)
 {
     if (byte_order == eByteOrderInvalid)
         byte_order = m_byte_order;
 
-    return PutRawBytes (&d, sizeof(d), lldb::endian::InlHostByteOrder(), byte_order);
+    return PutRawBytes (&d, sizeof(d), endian::InlHostByteOrder(), byte_order);
 }
 
 size_t
 Stream::PutLongDouble(long double ld, ByteOrder byte_order)
 {
     if (byte_order == eByteOrderInvalid)
         byte_order = m_byte_order;
 
-    return PutRawBytes (&ld, sizeof(ld), lldb::endian::InlHostByteOrder(), byte_order);
+    return PutRawBytes (&ld, sizeof(ld), endian::InlHostByteOrder(), byte_order);
 }
 
 size_t
 Stream::PutRawBytes (const void *s, size_t src_len, ByteOrder src_byte_order, ByteOrder dst_byte_order)
 {
     if (src_byte_order == eByteOrderInvalid)
         src_byte_order = m_byte_order;
 

 }
 
 void
 Stream::UnitTest(Stream *s)
 {
     s->PutHex8(0x12);
 
     s->PutChar(' ');
-    s->PutHex16(0x3456, lldb::endian::InlHostByteOrder());
+    s->PutHex16(0x3456, endian::InlHostByteOrder());
     s->PutChar(' ');
     s->PutHex16(0x3456, eByteOrderBig);
     s->PutChar(' ');
     s->PutHex16(0x3456, eByteOrderLittle);
 
     s->PutChar(' ');
-    s->PutHex32(0x789abcde, lldb::endian::InlHostByteOrder());
+    s->PutHex32(0x789abcde, endian::InlHostByteOrder());
     s->PutChar(' ');
     s->PutHex32(0x789abcde, eByteOrderBig);
     s->PutChar(' ');
     s->PutHex32(0x789abcde, eByteOrderLittle);
 
     s->PutChar(' ');
-    s->PutHex64(0x1122334455667788ull, lldb::endian::InlHostByteOrder());
+    s->PutHex64(0x1122334455667788ull, endian::InlHostByteOrder());
     s->PutChar(' ');
     s->PutHex64(0x1122334455667788ull, eByteOrderBig);
     s->PutChar(' ');
     s->PutHex64(0x1122334455667788ull, eByteOrderLittle);
 
     const char *hola = "Hello World!!!";
     s->PutChar(' ');
     s->PutCString (hola);

lldb/trunk/source/Core/Value.cpp

case eValueTypeScalar:
             const size_t scalar_size = rhs.m_value.GetByteSize();
             if (scalar_size > 0)
             {
                 const size_t new_size = curr_size + scalar_size;
                 if (ResizeData(new_size) == new_size)
                 {
                     rhs.m_value.GetAsMemoryData (m_data_buffer.GetBytes() + curr_size,
                                                  scalar_size,
-                                                 lldb::endian::InlHostByteOrder(),
+                                                 endian::InlHostByteOrder(),
                                                  error);
                     return scalar_size;
                 }
             }
         }
         break;
     case eValueTypeVector:
         {
case eValueTypeVector:
             data.SetAddressByteSize (ast_type.GetPointerByteSize());
         else
             data.SetAddressByteSize(sizeof(void *));
         data.SetData(m_vector.bytes, m_vector.length, m_vector.byte_order);
         break;
 
     case eValueTypeScalar:
         {
-            data.SetByteOrder (lldb::endian::InlHostByteOrder());
+            data.SetByteOrder (endian::InlHostByteOrder());
             if (ast_type.IsValid())
                 data.SetAddressByteSize (ast_type.GetPointerByteSize());
             else
                 data.SetAddressByteSize(sizeof(void *));
 
             uint32_t limit_byte_size = UINT32_MAX;
             
             if (ast_type.IsValid() && ast_type.IsScalarType())
case eValueTypeHostAddress:
             if (target)
             {
                 data.SetByteOrder(target->GetArchitecture().GetByteOrder());
                 data.SetAddressByteSize(target->GetArchitecture().GetAddressByteSize());
                 break;
             }
         }
         // fallback to host settings
-        data.SetByteOrder(lldb::endian::InlHostByteOrder());
+        data.SetByteOrder(endian::InlHostByteOrder());
         data.SetAddressByteSize(sizeof(void *));
         break;
     }
 
     // Bail if we encountered any errors
     if (error.Fail())
         return error;
 

lldb/trunk/source/Core/ValueObjectConstResultImpl.cpp

if (m_live_address != LLDB_INVALID_ADDRESS)
         
         std::string new_name("&");
         new_name.append(m_impl_backend->GetName().AsCString(""));
         ExecutionContext exe_ctx (m_impl_backend->GetExecutionContextRef());
         m_address_of_backend = ValueObjectConstResult::Create (exe_ctx.GetBestExecutionContextScope(),
                                                                compiler_type.GetPointerType(),
                                                                ConstString(new_name.c_str()),
                                                                buffer,
-                                                               lldb::endian::InlHostByteOrder(), 
+                                                               endian::InlHostByteOrder(),
                                                                exe_ctx.GetAddressByteSize());
         
         m_address_of_backend->GetValue().SetValueType(Value::eValueTypeScalar);
         m_address_of_backend->GetValue().GetScalar() = m_live_address;
         
         return m_address_of_backend;
     }
     else

lldb/trunk/source/Expression/IRInterpreter.cpp

bool ResolveConstant (lldb::addr_t process_address, const Constant *constant)
         lldb_private::StreamString buffer (lldb_private::Stream::eBinary,
                                            m_memory_map.GetAddressByteSize(),
                                            m_memory_map.GetByteOrder());
 
         size_t constant_size = m_target_data.getTypeStoreSize(constant->getType());
 
         const uint64_t *raw_data = resolved_value.getRawData();
 
-        buffer.PutRawBytes(raw_data, constant_size, lldb::endian::InlHostByteOrder());
+        buffer.PutRawBytes(raw_data, constant_size, lldb_private::endian::InlHostByteOrder());
 
         lldb_private::Error write_error;
 
         m_memory_map.WriteMemory(process_address, (const uint8_t*)buffer.GetData(), constant_size, write_error);
 
         return write_error.Success();
     }
 

lldb/trunk/source/Host/freebsd/Host.cpp

GetFreeBSDProcessArgs (const ProcessInstanceInfoMatch *match_info_ptr,
     if (process_info.ProcessIDIsValid())
     {
         int mib[4] = { CTL_KERN, KERN_PROC, KERN_PROC_ARGS, (int)process_info.GetProcessID() };
 
         char arg_data[8192];
         size_t arg_data_size = sizeof(arg_data);
         if (::sysctl (mib, 4, arg_data, &arg_data_size , NULL, 0) == 0)
         {
-            DataExtractor data (arg_data, arg_data_size, lldb::endian::InlHostByteOrder(), sizeof(void *));
+            DataExtractor data (arg_data, arg_data_size, endian::InlHostByteOrder(), sizeof(void *));
             lldb::offset_t offset = 0;
             const char *cstr;
 
             cstr = data.GetCStr (&offset);
             if (cstr)
             {
                 process_info.GetExecutableFile().SetFile(cstr, false);
 

lldb/trunk/source/Host/macosx/Host.mm

if (process_info.ProcessIDIsValid())
             arg_data_size = 8192;
 
         // Add a few bytes to the calculated length, I know we need to add at least one byte
         // to this number otherwise we get junk back, so add 128 just in case...
         DataBufferHeap arg_data(arg_data_size+128, 0);
         arg_data_size = arg_data.GetByteSize();
         if (::sysctl (proc_args_mib, 3, arg_data.GetBytes(), &arg_data_size , NULL, 0) == 0)
         {
-            DataExtractor data (arg_data.GetBytes(), arg_data_size, lldb::endian::InlHostByteOrder(), sizeof(void *));
+            DataExtractor data (arg_data.GetBytes(), arg_data_size, endian::InlHostByteOrder(), sizeof(void *));
             lldb::offset_t offset = 0;
             uint32_t argc = data.GetU32 (&offset);
             llvm::Triple &triple = process_info.GetArchitecture().GetTriple();
             const llvm::Triple::ArchType triple_arch = triple.getArch();
             const bool check_for_ios_simulator = (triple_arch == llvm::Triple::x86 || triple_arch == llvm::Triple::x86_64);
             const char *cstr = data.GetCStr (&offset);
             if (cstr)
             {

lldb/trunk/source/Host/netbsd/Host.cpp

GetNetBSDProcessArgs (const ProcessInstanceInfoMatch *match_info_ptr,
 
     int mib[4] = { CTL_KERN, KERN_PROC_ARGS, pid, KERN_PROC_ARGV };
 
     char arg_data[8192];
     size_t arg_data_size = sizeof(arg_data);
     if (::sysctl (mib, 4, arg_data, &arg_data_size , NULL, 0) != 0)
         return false;
 
-    DataExtractor data (arg_data, arg_data_size, lldb::endian::InlHostByteOrder(), sizeof(void *));
+    DataExtractor data (arg_data, arg_data_size, endian::InlHostByteOrder(), sizeof(void *));
     lldb::offset_t offset = 0;
     const char *cstr;
 
     cstr = data.GetCStr (&offset);
     if (!cstr)
         return false;
 
     process_info.GetExecutableFile().SetFile(cstr, false);

lldb/trunk/source/Plugins/DynamicLoader/Darwin-Kernel/DynamicLoaderDarwinKernel.cpp

 
 lldb::ByteOrder
 DynamicLoaderDarwinKernel::KextImageInfo::GetByteOrder()
 {
     if (m_memory_module_sp)
         return m_memory_module_sp->GetArchitecture().GetByteOrder();
     if (m_module_sp)
         return m_module_sp->GetArchitecture().GetByteOrder();
-    return lldb::endian::InlHostByteOrder();
+    return endian::InlHostByteOrder();
 }
 
 lldb_private::ArchSpec
 DynamicLoaderDarwinKernel::KextImageInfo::GetArchitecture () const
 {
     if (m_memory_module_sp)
         return m_memory_module_sp->GetArchitecture();
     if (m_module_sp)

 
 lldb::ByteOrder
 DynamicLoaderDarwinKernel::GetByteOrderFromMagic (uint32_t magic)
 {
     switch (magic)
     {
         case llvm::MachO::MH_MAGIC:
         case llvm::MachO::MH_MAGIC_64:
-            return lldb::endian::InlHostByteOrder();
+            return endian::InlHostByteOrder();
             
         case llvm::MachO::MH_CIGAM:
         case llvm::MachO::MH_CIGAM_64:
-            if (lldb::endian::InlHostByteOrder() == lldb::eByteOrderBig)
+            if (endian::InlHostByteOrder() == lldb::eByteOrderBig)
                 return lldb::eByteOrderLittle;
             else
                 return lldb::eByteOrderBig;
             
         default:
             break;
     }
     return lldb::eByteOrderInvalid;
 }
 

lldb/trunk/source/Plugins/DynamicLoader/MacOSX-DYLD/DynamicLoaderMacOSXDYLD.cpp

size_t bytes_read = m_process->ReadMemory (addr,
                                                header_bytes.GetByteSize(), 
                                                error);
     if (bytes_read == sizeof(llvm::MachO::mach_header))
     {
         lldb::offset_t offset = 0;
         ::memset (header, 0, sizeof(llvm::MachO::mach_header));
 
         // Get the magic byte unswapped so we can figure out what we are dealing with
-        DataExtractor data(header_bytes.GetBytes(), header_bytes.GetByteSize(), lldb::endian::InlHostByteOrder(), 4);
+        DataExtractor data(header_bytes.GetBytes(), header_bytes.GetByteSize(), endian::InlHostByteOrder(), 4);
         header->magic = data.GetU32(&offset);
         lldb::addr_t load_cmd_addr = addr;
         data.SetByteOrder(DynamicLoaderMacOSXDYLD::GetByteOrderFromMagic(header->magic));
         switch (header->magic)
         {
         case llvm::MachO::MH_MAGIC:
         case llvm::MachO::MH_CIGAM:
             data.SetAddressByteSize(4);

 
 lldb::ByteOrder
 DynamicLoaderMacOSXDYLD::GetByteOrderFromMagic (uint32_t magic)
 {
     switch (magic)
     {
         case llvm::MachO::MH_MAGIC:
         case llvm::MachO::MH_MAGIC_64:
-            return lldb::endian::InlHostByteOrder();
+            return endian::InlHostByteOrder();
             
         case llvm::MachO::MH_CIGAM:
         case llvm::MachO::MH_CIGAM_64:
-            if (lldb::endian::InlHostByteOrder() == lldb::eByteOrderBig)
+            if (endian::InlHostByteOrder() == lldb::eByteOrderBig)
                 return lldb::eByteOrderLittle;
             else
                 return lldb::eByteOrderBig;
             
         default:
             break;
     }
     return lldb::eByteOrderInvalid;
 }
 
 lldb::ByteOrder
 DynamicLoaderMacOSXDYLD::DYLDImageInfo::GetByteOrder()
 {
     return DynamicLoaderMacOSXDYLD::GetByteOrderFromMagic(header.magic);
 }
 

lldb/trunk/source/Plugins/ExpressionParser/Clang/IRForTarget.cpp

for (constant_iter = static_constants.begin(), user_iter = static_users.begin();
                 }
                 ss.flush();
 
                 log->Printf("Found ConstantFP with size %" PRIu64 " and raw data %s", (uint64_t)operand_data_size, s.c_str());
             }
 
             lldb_private::DataBufferHeap data(operand_data_size, 0);
 
-            if (lldb::endian::InlHostByteOrder() != m_data_allocator.GetStream().GetByteOrder())
+            if (lldb_private::endian::InlHostByteOrder() != m_data_allocator.GetStream().GetByteOrder())
             {
                 uint8_t *data_bytes = data.GetBytes();
 
                 for (size_t index = 0;
                      index < operand_data_size;
                      ++index)
                 {
                     data_bytes[index] = operand_raw_data[operand_data_size - (1 + index)];

lldb/trunk/source/Plugins/ObjectFile/Mach-O/ObjectFileMachO.cpp

ObjectFileMachO::ObjectFileMachO (const lldb::ModuleSP &module_sp,
     ::memset (&m_dysymtab, 0, sizeof(m_dysymtab));
 }
 
 bool
 ObjectFileMachO::ParseHeader (DataExtractor &data,
                               lldb::offset_t *data_offset_ptr,
                               llvm::MachO::mach_header &header)
 {
-    data.SetByteOrder (lldb::endian::InlHostByteOrder());
+    data.SetByteOrder (endian::InlHostByteOrder());
     // Leave magic in the original byte order
     header.magic = data.GetU32(data_offset_ptr);
     bool can_parse = false;
     bool is_64_bit = false;
     switch (header.magic)
     {
         case MH_MAGIC:
-            data.SetByteOrder (lldb::endian::InlHostByteOrder());
+            data.SetByteOrder (endian::InlHostByteOrder());
             data.SetAddressByteSize(4);
             can_parse = true;
             break;
             
         case MH_MAGIC_64:
-            data.SetByteOrder (lldb::endian::InlHostByteOrder());
+            data.SetByteOrder (endian::InlHostByteOrder());
             data.SetAddressByteSize(8);
             can_parse = true;
             is_64_bit = true;
             break;
             
         case MH_CIGAM:
-            data.SetByteOrder(lldb::endian::InlHostByteOrder() == eByteOrderBig ? eByteOrderLittle : eByteOrderBig);
+            data.SetByteOrder(endian::InlHostByteOrder() == eByteOrderBig ? eByteOrderLittle : eByteOrderBig);
             data.SetAddressByteSize(4);
             can_parse = true;
             break;
             
         case MH_CIGAM_64:
-            data.SetByteOrder(lldb::endian::InlHostByteOrder() == eByteOrderBig ? eByteOrderLittle : eByteOrderBig);
+            data.SetByteOrder(endian::InlHostByteOrder() == eByteOrderBig ? eByteOrderLittle : eByteOrderBig);
             data.SetAddressByteSize(8);
             is_64_bit = true;
             can_parse = true;
             break;
             
         default:
             break;
     }

 ObjectFileMachO::ParseHeader ()
 {
     ModuleSP module_sp(GetModule());
     if (module_sp)
     {
         lldb_private::Mutex::Locker locker(module_sp->GetMutex());
         bool can_parse = false;
         lldb::offset_t offset = 0;
-        m_data.SetByteOrder (lldb::endian::InlHostByteOrder());
+        m_data.SetByteOrder (endian::InlHostByteOrder());
         // Leave magic in the original byte order
         m_header.magic = m_data.GetU32(&offset);
         switch (m_header.magic)
         {
         case MH_MAGIC:
-            m_data.SetByteOrder (lldb::endian::InlHostByteOrder());
+            m_data.SetByteOrder (endian::InlHostByteOrder());
             m_data.SetAddressByteSize(4);
             can_parse = true;
             break;
 
         case MH_MAGIC_64:
-            m_data.SetByteOrder (lldb::endian::InlHostByteOrder());
+            m_data.SetByteOrder (endian::InlHostByteOrder());
             m_data.SetAddressByteSize(8);
             can_parse = true;
             break;
 
         case MH_CIGAM:
-            m_data.SetByteOrder(lldb::endian::InlHostByteOrder() == eByteOrderBig ? eByteOrderLittle : eByteOrderBig);
+            m_data.SetByteOrder(endian::InlHostByteOrder() == eByteOrderBig ? eByteOrderLittle : eByteOrderBig);
             m_data.SetAddressByteSize(4);
             can_parse = true;
             break;
 
         case MH_CIGAM_64:
-            m_data.SetByteOrder(lldb::endian::InlHostByteOrder() == eByteOrderBig ? eByteOrderLittle : eByteOrderBig);
+            m_data.SetByteOrder(endian::InlHostByteOrder() == eByteOrderBig ? eByteOrderLittle : eByteOrderBig);
             m_data.SetAddressByteSize(8);
             can_parse = true;
             break;
 
         default:
             break;
         }
 

lldb/trunk/source/Plugins/Process/FreeBSD/ProcessFreeBSD.cpp

ProcessFreeBSD::SendMessage(const ProcessMessage &message)
     m_message_queue.push(message);
 }
 
 //------------------------------------------------------------------------------
 // Constructors and destructors.
 
 ProcessFreeBSD::ProcessFreeBSD(lldb::TargetSP target_sp, Listener &listener, UnixSignalsSP &unix_signals_sp)
     : Process(target_sp, listener, unix_signals_sp),
-      m_byte_order(lldb::endian::InlHostByteOrder()),
+      m_byte_order(endian::InlHostByteOrder()),
       m_monitor(NULL),
       m_module(NULL),
       m_message_mutex (Mutex::eMutexTypeRecursive),
       m_exit_now(false),
       m_seen_initial_stop(),
       m_resume_signo(0)
 {
     // FIXME: Putting this code in the ctor and saving the byte order in a

lldb/trunk/source/Plugins/Process/MacOSX-Kernel/ProcessKDP.cpp

DoExecute (Args& command, CommandReturnObject &result)
                                                                         error);
                             
                             if (error.Success())
                             {
                                 // Copy the binary bytes into a hex ASCII string for the result
                                 StreamString packet;
                                 packet.PutBytesAsRawHex8(reply.GetDataStart(),
                                                          reply.GetByteSize(),
-                                                         lldb::endian::InlHostByteOrder(),
-                                                         lldb::endian::InlHostByteOrder());
+                                                         endian::InlHostByteOrder(),
+                                                         endian::InlHostByteOrder());
                                 result.AppendMessage(packet.GetString().c_str());
                                 result.SetStatus (eReturnStatusSuccessFinishResult);
                                 return true;
                             }
                             else
                             {
                                 const char *error_cstr = error.AsCString();
                                 if (error_cstr && error_cstr[0])

lldb/trunk/source/Plugins/Process/Utility/RegisterContextDarwin_arm64.cpp

RegisterContextDarwin_arm64::ReadRegister (const RegisterInfo *reg_info, RegisterValue &value)
     case fpu_v24:
     case fpu_v25:
     case fpu_v26:
     case fpu_v27:
     case fpu_v28:
     case fpu_v29:
     case fpu_v30:
     case fpu_v31:
-        value.SetBytes(fpu.v[reg].bytes, reg_info->byte_size, lldb::endian::InlHostByteOrder());
+        value.SetBytes(fpu.v[reg].bytes, reg_info->byte_size, endian::InlHostByteOrder());
         break;
 
     case fpu_fpsr:
         value.SetUInt32 (fpu.fpsr);
         break;
 
     case fpu_fpcr:
         value.SetUInt32 (fpu.fpcr);

lldb/trunk/source/Plugins/Process/Utility/RegisterContextDarwin_x86_64.cpp

RegisterContextDarwin_x86_64::ReadRegister (const RegisterInfo *reg_info,
     case fpu_stmm0:
     case fpu_stmm1:
     case fpu_stmm2:
     case fpu_stmm3:
     case fpu_stmm4:
     case fpu_stmm5:
     case fpu_stmm6:
     case fpu_stmm7:
-        value.SetBytes(fpu.stmm[reg - fpu_stmm0].bytes, reg_info->byte_size, lldb::endian::InlHostByteOrder());
+        value.SetBytes(fpu.stmm[reg - fpu_stmm0].bytes, reg_info->byte_size, endian::InlHostByteOrder());
         break;
 
     case fpu_xmm0:
     case fpu_xmm1:
     case fpu_xmm2:
     case fpu_xmm3:
     case fpu_xmm4:
     case fpu_xmm5:
     case fpu_xmm6:
     case fpu_xmm7:
     case fpu_xmm8:
     case fpu_xmm9:
     case fpu_xmm10:
     case fpu_xmm11:
     case fpu_xmm12:
     case fpu_xmm13:
     case fpu_xmm14:
     case fpu_xmm15:
-        value.SetBytes(fpu.xmm[reg - fpu_xmm0].bytes, reg_info->byte_size, lldb::endian::InlHostByteOrder());
+        value.SetBytes(fpu.xmm[reg - fpu_xmm0].bytes, reg_info->byte_size, endian::InlHostByteOrder());
         break;
 
     case exc_trapno:
         value = exc.trapno;
         break;
 
     case exc_err:
         value = exc.err;

lldb/trunk/source/Plugins/Process/gdb-remote/GDBRemoteCommunicationServerCommon.cpp

if (host_arch.GetMachine() == llvm::Triple::aarch64 ||
         host_arch.GetMachine() == llvm::Triple::mips64el ||
         host_arch.GetMachine() == llvm::Triple::mips ||
         host_arch.GetMachine() == llvm::Triple::mipsel)
         response.Printf("watchpoint_exceptions_received:before;");
     else
         response.Printf("watchpoint_exceptions_received:after;");
 #endif
 
-    switch (lldb::endian::InlHostByteOrder())
+    switch (endian::InlHostByteOrder())
     {
     case eByteOrderBig:     response.PutCString ("endian:big;"); break;
     case eByteOrderLittle:  response.PutCString ("endian:little;"); break;
     case eByteOrderPDP:     response.PutCString ("endian:pdp;"); break;
     default:                response.PutCString ("endian:unknown;"); break;
     }
 
     uint32_t major = UINT32_MAX;

lldb/trunk/source/Plugins/Process/gdb-remote/GDBRemoteRegisterContext.cpp

GDBRemoteRegisterContext::SetPrimordialRegister(const RegisterInfo *reg_info,
                                                 GDBRemoteCommunicationClient &gdb_comm)
 {
     StreamString packet;
     StringExtractorGDBRemote response;
     const uint32_t reg = reg_info->kinds[eRegisterKindLLDB];
     packet.Printf ("P%x=", reg);
     packet.PutBytesAsRawHex8 (m_reg_data.PeekData(reg_info->byte_offset, reg_info->byte_size),
                               reg_info->byte_size,
-                              lldb::endian::InlHostByteOrder(),
-                              lldb::endian::InlHostByteOrder());
+                              endian::InlHostByteOrder(),
+                              endian::InlHostByteOrder());
 
     if (gdb_comm.GetThreadSuffixSupported())
         packet.Printf (";thread:%4.4" PRIx64 ";", m_thread.GetProtocolID());
 
     // Invalidate just this register
     SetRegisterIsValid(reg, false);
     if (gdb_comm.SendPacketAndWaitForResponse(packet.GetString().c_str(),
                                               packet.GetString().size(),
if (data.CopyByteOrderedData (data_offset,                  // src offset
                 StringExtractorGDBRemote response;
                 
                 if (m_read_all_at_once)
                 {
                     // Set all registers in one packet
                     packet.PutChar ('G');
                     packet.PutBytesAsRawHex8 (m_reg_data.GetDataStart(),
                                               m_reg_data.GetByteSize(),
-                                              lldb::endian::InlHostByteOrder(),
-                                              lldb::endian::InlHostByteOrder());
+                                              endian::InlHostByteOrder(),
+                                              endian::InlHostByteOrder());
 
                     if (thread_suffix_supported)
                         packet.Printf (";thread:%4.4" PRIx64 ";", m_thread.GetProtocolID());
 
                     // Invalidate all register values
                     InvalidateIfNeeded (true);
 
                     if (gdb_comm.SendPacketAndWaitForResponse(packet.GetString().c_str(),
if (gdb_comm.GetSequenceMutex (locker, "Didn't get sequence mutex for write all registers."))
     
                             const char *restore_src = (const char *)restore_data.PeekData(register_offset, reg_byte_size);
                             if (restore_src)
                             {
                                 StreamString packet;
                                 packet.Printf ("P%x=", reg);
                                 packet.PutBytesAsRawHex8 (restore_src,
                                                           reg_byte_size,
-                                                          lldb::endian::InlHostByteOrder(),
-                                                          lldb::endian::InlHostByteOrder());
+                                                          endian::InlHostByteOrder(),
+                                                          endian::InlHostByteOrder());
 
                                 if (thread_suffix_supported)
                                     packet.Printf (";thread:%4.4" PRIx64 ";", m_thread.GetProtocolID());
 
                                 SetRegisterIsValid(reg, false);
                                 if (gdb_comm.SendPacketAndWaitForResponse(packet.GetString().c_str(),
                                                                           packet.GetString().size(),
                                                                           response,
                                                                           false) == GDBRemoteCommunication::PacketResult::Success)
                                 {
                                     const char *current_src = (const char *)m_reg_data.PeekData(register_offset, reg_byte_size);
                                     if (current_src)
                                         write_reg = memcmp (current_src, restore_src, reg_byte_size) != 0;
                                 }
     
                                 if (write_reg)
                                 {
                                     StreamString packet;
                                     packet.Printf ("P%x=", reg);
                                     packet.PutBytesAsRawHex8 (restore_src,
                                                               reg_byte_size,
-                                                              lldb::endian::InlHostByteOrder(),
-                                                              lldb::endian::InlHostByteOrder());
+                                                              endian::InlHostByteOrder(),
+                                                              endian::InlHostByteOrder());
     
                                     if (thread_suffix_supported)
                                         packet.Printf (";thread:%4.4" PRIx64 ";", m_thread.GetProtocolID());
     
                                     SetRegisterIsValid(reg, false);
                                     if (gdb_comm.SendPacketAndWaitForResponse(packet.GetString().c_str(),
                                                                               packet.GetString().size(),
                                                                               response,
if (gdb_comm.GetSequenceMutex (locker, "Didn't get sequence mutex for write all registers."))
                     // register context corruption when writing fpsr/fpcr.
                     if (arm64_debugserver &&
                         (strcmp (reg_info->name, "fpsr") == 0 || strcmp (reg_info->name, "fpcr") == 0))
                     {
                         continue;
                     }
                     StreamString packet;
                     packet.Printf ("P%x=", reg_info->kinds[eRegisterKindLLDB]);
-                    packet.PutBytesAsRawHex8 (data_sp->GetBytes() + reg_info->byte_offset, reg_info->byte_size, lldb::endian::InlHostByteOrder(), lldb::endian::InlHostByteOrder());
+                    packet.PutBytesAsRawHex8 (data_sp->GetBytes() + reg_info->byte_offset, reg_info->byte_size, endian::InlHostByteOrder(), endian::InlHostByteOrder());
                     if (thread_suffix_supported)
                         packet.Printf (";thread:%4.4" PRIx64 ";", m_thread.GetProtocolID());
 
                     SetRegisterIsValid(reg_info, false);
                     if (gdb_comm.SendPacketAndWaitForResponse(packet.GetString().c_str(),
                                                               packet.GetString().size(),
                                                               response,
                                                               false) == GDBRemoteCommunication::PacketResult::Success)

lldb/trunk/source/Plugins/Process/gdb-remote/ProcessGDBRemote.cpp

if (process_name && process_name[0])
                         packet.PutCString("vAttachWait");
                     else
                         packet.PutCString ("vAttachOrWait");
                 }
             }
             else
                 packet.PutCString("vAttachName");
             packet.PutChar(';');
-            packet.PutBytesAsRawHex8(process_name, strlen(process_name), lldb::endian::InlHostByteOrder(), lldb::endian::InlHostByteOrder());
+            packet.PutBytesAsRawHex8(process_name, strlen(process_name), endian::InlHostByteOrder(), endian::InlHostByteOrder());
             
             m_async_broadcaster.BroadcastEvent (eBroadcastBitAsyncContinue, new EventDataBytes (packet.GetData(), packet.GetSize()));
 
         }
     }
     return error;
 }
 
if (size > m_max_memory_size)
         // Keep memory read sizes down to a sane limit. This function will be
         // called multiple times in order to complete the task by 
         // lldb_private::Process so it is ok to do this.
         size = m_max_memory_size;
     }
 
     StreamString packet;
     packet.Printf("M%" PRIx64 ",%" PRIx64 ":", addr, (uint64_t)size);
-    packet.PutBytesAsRawHex8(buf, size, lldb::endian::InlHostByteOrder(), lldb::endian::InlHostByteOrder());
+    packet.PutBytesAsRawHex8(buf, size, endian::InlHostByteOrder(), endian::InlHostByteOrder());
     StringExtractorGDBRemote response;
     if (m_gdb_comm.SendPacketAndWaitForResponse(packet.GetData(), packet.GetSize(), response, true) == GDBRemoteCommunication::PacketResult::Success)
     {
         if (response.IsOKResponse())
         {
             error.Clear();
             return size;
         }

lldb/trunk/source/Target/ExecutionContext.cpp

 
 lldb::ByteOrder
 ExecutionContext::GetByteOrder() const
 {
     if (m_target_sp && m_target_sp->GetArchitecture().IsValid())
         m_target_sp->GetArchitecture().GetByteOrder();
     if (m_process_sp)
         m_process_sp->GetByteOrder();
-    return lldb::endian::InlHostByteOrder();
+    return endian::InlHostByteOrder();
 }
 
 RegisterContext *
 ExecutionContext::GetRegisterContext () const
 {
     if (m_frame_sp)
         return m_frame_sp->GetRegisterContext().get();
     else if (m_thread_sp)

lldb/trunk/source/Target/RegisterContext.cpp

 //        }
 //        break;
 //    case eEncodingSint:
 //        switch (reg_info->byte_size)
 //        {
 //        case 1:
 //            {
 //                int8_t v;
-//                if (data.ExtractBytes (0, sizeof (int8_t), lldb::endian::InlHostByteOrder(), &v) != sizeof (int8_t))
+//                if (data.ExtractBytes (0, sizeof (int8_t), endian::InlHostByteOrder(), &v) != sizeof (int8_t))
 //                    return false;
 //                value = v;
 //                return true;
 //            }
 //        case 2:
 //            {
 //                int16_t v;
-//                if (data.ExtractBytes (0, sizeof (int16_t), lldb::endian::InlHostByteOrder(), &v) != sizeof (int16_t))
+//                if (data.ExtractBytes (0, sizeof (int16_t), endian::InlHostByteOrder(), &v) != sizeof (int16_t))
 //                    return false;
 //                value = v;
 //                return true;
 //            }
 //        case 4:
 //            {
 //                int32_t v;
-//                if (data.ExtractBytes (0, sizeof (int32_t), lldb::endian::InlHostByteOrder(), &v) != sizeof (int32_t))
+//                if (data.ExtractBytes (0, sizeof (int32_t), endian::InlHostByteOrder(), &v) != sizeof (int32_t))
 //                    return false;
 //                value = v;
 //                return true;
 //            }
 //        case 8:
 //            {
 //                int64_t v;
-//                if (data.ExtractBytes (0, sizeof (int64_t), lldb::endian::InlHostByteOrder(), &v) != sizeof (int64_t))
+//                if (data.ExtractBytes (0, sizeof (int64_t), endian::InlHostByteOrder(), &v) != sizeof (int64_t))
 //                    return false;
 //                value = v;
 //                return true;
 //            }
 //        }
 //        break;
 //    case eEncodingIEEE754:
 //        switch (reg_info->byte_size)
 //        {
 //        case sizeof (float):
 //            {
 //                float v;
-//                if (data.ExtractBytes (0, sizeof (float), lldb::endian::InlHostByteOrder(), &v) != sizeof (float))
+//                if (data.ExtractBytes (0, sizeof (float), endian::InlHostByteOrder(), &v) != sizeof (float))
 //                    return false;
 //                value = v;
 //                return true;
 //            }
 //        case sizeof (double):
 //            {
 //                double v;
-//                if (data.ExtractBytes (0, sizeof (double), lldb::endian::InlHostByteOrder(), &v) != sizeof (double))
+//                if (data.ExtractBytes (0, sizeof (double), endian::InlHostByteOrder(), &v) != sizeof (double))
 //                    return false;
 //                value = v;
 //                return true;
 //            }
 //        case sizeof (long double):
 //            {
 //                double v;
-//                if (data.ExtractBytes (0, sizeof (long double), lldb::endian::InlHostByteOrder(), &v) != sizeof (long double))
+//                if (data.ExtractBytes (0, sizeof (long double), endian::InlHostByteOrder(), &v) != sizeof (long double))
 //                    return false;
 //                value = v;
 //                return true;
 //            }
 //        }
 //        break;
 //    }
 //    return false;