MFC r262528: Update LLDB snapshot to upstream r202189

  Highlights include (upstream revs in parens):

  - Improvements to the remote GDB protocol client
    (r196610, r197579, r197857, r200072, and others)

  - Bug fixes for big-endian targets
    (r196808)

  - Initial support for libdispatch (GCD) queues in the debuggee
    (r197190)

  - Add "step-avoid-libraries" setting
    (r199943)

  - IO subsystem improvements (including initial work on a curses gui)
    (r200263)

  - Support hardware watchpoints on FreeBSD
    (r201706)

  - Improved unwinding through hand-written assembly functions
    (r201839)

  - Handle DW_TAG_unspecified_parameters for variadic functions
    (r202061)

  - Fix Ctrl+C interrupting a running inferior process
    (r202086, r202154)

  - Various bug fixes for memory leaks, LLDB segfaults, the C++ demangler,
    ELF core files, DWARF debug info, and others.

Sponsored by:	DARPA, AFRL

1 files changed, 96 insertions, 3 deletions

diff --git a/contrib/llvm/tools/lldb/source/Expression/DWARFExpression.cpp b/contrib/llvm/tools/lldb/source/Expression/DWARFExpression.cpp
index b36be8e..28aa6d0 100644
--- a/contrib/llvm/tools/lldb/source/Expression/DWARFExpression.cpp
+++ b/contrib/llvm/tools/lldb/source/Expression/DWARFExpression.cpp
@@ -1429,6 +1429,12 @@ DWARFExpression::Evaluate
         //----------------------------------------------------------------------
         case DW_OP_deref:
             {
+                if (stack.empty())
+                {
+                    if (error_ptr)
+                        error_ptr->SetErrorString("Expression stack empty for DW_OP_deref.");
+                    return false;
+                }
                 Value::ValueType value_type = stack.back().GetValueType();
                 switch (value_type)
                 {
@@ -1504,6 +1510,12 @@ DWARFExpression::Evaluate
         //----------------------------------------------------------------------
         case DW_OP_deref_size:
             {
+                if (stack.empty())
+                {
+                    if (error_ptr)
+                        error_ptr->SetErrorString("Expression stack empty for DW_OP_deref_size.");
+                    return false;
+                }
                 uint8_t size = opcodes.GetU8(&offset);
                 Value::ValueType value_type = stack.back().GetValueType();
                 switch (value_type)
@@ -2562,9 +2574,90 @@ DWARFExpression::Evaluate
         // variable a particular DWARF expression refers to.
         //----------------------------------------------------------------------
         case DW_OP_piece:
-            if (error_ptr)
-                error_ptr->SetErrorString ("Unimplemented opcode DW_OP_piece.");
-            return false;
+            if (stack.size() < 1)
+            {
+                if (error_ptr)
+                    error_ptr->SetErrorString("Expression stack needs at least 1 item for DW_OP_piece.");
+                return false;
+            }
+            else
+            {
+                const uint64_t piece_byte_size = opcodes.GetULEB128(&offset);
+                switch (stack.back().GetValueType())
+                {
+                    case Value::eValueTypeScalar:
+                    case Value::eValueTypeFileAddress:
+                    case Value::eValueTypeLoadAddress:
+                    case Value::eValueTypeHostAddress:
+                        {
+                            uint32_t bit_size = piece_byte_size * 8;
+                            uint32_t bit_offset = 0;
+                            if (!stack.back().GetScalar().ExtractBitfield (bit_size, bit_offset))
+                            {
+                                if (error_ptr)
+                                    error_ptr->SetErrorStringWithFormat("unable to extract %" PRIu64 " bytes from a %" PRIu64 " byte scalar value.", piece_byte_size, (uint64_t)stack.back().GetScalar().GetByteSize());
+                                return false;
+                            }
+                        }
+                        break;
+                        
+                    case Value::eValueTypeVector:
+                        {
+                            if (stack.back().GetVector().length >= piece_byte_size)
+                                stack.back().GetVector().length = piece_byte_size;
+                            else
+                            {
+                                if (error_ptr)
+                                    error_ptr->SetErrorStringWithFormat("unable to extract %" PRIu64 " bytes from a %" PRIu64 " byte vector value.", piece_byte_size, (uint64_t)stack.back().GetVector().length);
+                                return false;
+                            }
+                        }
+                        break;
+                }
+            }
+            break;
+
+        case DW_OP_bit_piece:   // 0x9d ULEB128 bit size, ULEB128 bit offset (DWARF3);
+            if (stack.size() < 1)
+            {
+                if (error_ptr)
+                    error_ptr->SetErrorString("Expression stack needs at least 1 item for DW_OP_bit_piece.");
+                return false;
+            }
+            else
+            {
+                const uint64_t piece_bit_size = opcodes.GetULEB128(&offset);
+                const uint64_t piece_bit_offset = opcodes.GetULEB128(&offset);
+                switch (stack.back().GetValueType())
+                {
+                case Value::eValueTypeScalar:
+                case Value::eValueTypeFileAddress:
+                case Value::eValueTypeLoadAddress:
+                case Value::eValueTypeHostAddress:
+                    {
+                        if (!stack.back().GetScalar().ExtractBitfield (piece_bit_size, piece_bit_offset))
+                        {
+                            if (error_ptr)
+                                error_ptr->SetErrorStringWithFormat("unable to extract %" PRIu64 " bit value with %" PRIu64 " bit offset from a %" PRIu64 " bit scalar value.",
+                                                                    piece_bit_size,
+                                                                    piece_bit_offset,
+                                                                    (uint64_t)(stack.back().GetScalar().GetByteSize()*8));
+                            return false;
+                        }
+                    }
+                    break;
+                    
+                case Value::eValueTypeVector:
+                    if (error_ptr)
+                    {
+                        error_ptr->SetErrorStringWithFormat ("unable to extract %" PRIu64 " bit value with %" PRIu64 " bit offset from a vector value.",
+                                                             piece_bit_size,
+                                                             piece_bit_offset);
+                    }
+                    return false;
+                }
+            }
+            break;
 
         //----------------------------------------------------------------------
         // OPCODE: DW_OP_push_object_address