Import LLVM 10.0.0 release including clang, lld and lldb.

ok hackroom
tested by plenty

1 files changed, 316 insertions, 0 deletions

diff --git a/gnu/llvm/lldb/source/Interpreter/OptionValueArray.cpp b/gnu/llvm/lldb/source/Interpreter/OptionValueArray.cpp
new file mode 100644
index 00000000000..30902c0f295
--- /dev/null
+++ b/gnu/llvm/lldb/source/Interpreter/OptionValueArray.cpp
@@ -0,0 +1,316 @@
+//===-- OptionValueArray.cpp ------------------------------------*- C++ -*-===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+#include "lldb/Interpreter/OptionValueArray.h"
+
+#include "lldb/Host/StringConvert.h"
+#include "lldb/Utility/Args.h"
+#include "lldb/Utility/Stream.h"
+
+using namespace lldb;
+using namespace lldb_private;
+
+void OptionValueArray::DumpValue(const ExecutionContext *exe_ctx, Stream &strm,
+                                 uint32_t dump_mask) {
+  const Type array_element_type = ConvertTypeMaskToType(m_type_mask);
+  if (dump_mask & eDumpOptionType) {
+    if ((GetType() == eTypeArray) && (m_type_mask != eTypeInvalid))
+      strm.Printf("(%s of %ss)", GetTypeAsCString(),
+                  GetBuiltinTypeAsCString(array_element_type));
+    else
+      strm.Printf("(%s)", GetTypeAsCString());
+  }
+  if (dump_mask & eDumpOptionValue) {
+    const bool one_line = dump_mask & eDumpOptionCommand;
+    const uint32_t size = m_values.size();
+    if (dump_mask & eDumpOptionType)
+      strm.Printf(" =%s", (m_values.size() > 0 && !one_line) ? "\n" : "");
+    if (!one_line)
+      strm.IndentMore();
+    for (uint32_t i = 0; i < size; ++i) {
+      if (!one_line) {
+        strm.Indent();
+        strm.Printf("[%u]: ", i);
+      }
+      const uint32_t extra_dump_options = m_raw_value_dump ? eDumpOptionRaw : 0;
+      switch (array_element_type) {
+      default:
+      case eTypeArray:
+      case eTypeDictionary:
+      case eTypeProperties:
+      case eTypeFileSpecList:
+      case eTypePathMap:
+        m_values[i]->DumpValue(exe_ctx, strm, dump_mask | extra_dump_options);
+        break;
+
+      case eTypeBoolean:
+      case eTypeChar:
+      case eTypeEnum:
+      case eTypeFileSpec:
+      case eTypeFormat:
+      case eTypeSInt64:
+      case eTypeString:
+      case eTypeUInt64:
+      case eTypeUUID:
+        // No need to show the type for dictionaries of simple items
+        m_values[i]->DumpValue(exe_ctx, strm, (dump_mask & (~eDumpOptionType)) |
+                                                  extra_dump_options);
+        break;
+      }
+
+      if (!one_line) {
+        if (i < (size - 1))
+          strm.EOL();
+      } else {
+        strm << ' ';
+      }
+    }
+    if (!one_line)
+      strm.IndentLess();
+  }
+}
+
+Status OptionValueArray::SetValueFromString(llvm::StringRef value,
+                                            VarSetOperationType op) {
+  Args args(value.str());
+  Status error = SetArgs(args, op);
+  if (error.Success())
+    NotifyValueChanged();
+  return error;
+}
+
+lldb::OptionValueSP
+OptionValueArray::GetSubValue(const ExecutionContext *exe_ctx,
+                              llvm::StringRef name, bool will_modify,
+                              Status &error) const {
+  if (name.empty() || name.front() != '[') {
+    error.SetErrorStringWithFormat(
+      "invalid value path '%s', %s values only support '[<index>]' subvalues "
+      "where <index> is a positive or negative array index",
+      name.str().c_str(), GetTypeAsCString());
+    return nullptr;
+  }
+
+  name = name.drop_front();
+  llvm::StringRef index, sub_value;
+  std::tie(index, sub_value) = name.split(']');
+  if (index.size() == name.size()) {
+    // Couldn't find a closing bracket
+    return nullptr;
+  }
+
+  const size_t array_count = m_values.size();
+  int32_t idx = 0;
+  if (index.getAsInteger(0, idx))
+    return nullptr;
+
+  uint32_t new_idx = UINT32_MAX;
+  if (idx < 0) {
+    // Access from the end of the array if the index is negative
+    new_idx = array_count - idx;
+  } else {
+    // Just a standard index
+    new_idx = idx;
+  }
+
+  if (new_idx < array_count) {
+    if (m_values[new_idx]) {
+      if (!sub_value.empty())
+        return m_values[new_idx]->GetSubValue(exe_ctx, sub_value,
+                                              will_modify, error);
+      else
+        return m_values[new_idx];
+    }
+  } else {
+    if (array_count == 0)
+      error.SetErrorStringWithFormat(
+          "index %i is not valid for an empty array", idx);
+    else if (idx > 0)
+      error.SetErrorStringWithFormat(
+          "index %i out of range, valid values are 0 through %" PRIu64,
+          idx, (uint64_t)(array_count - 1));
+    else
+      error.SetErrorStringWithFormat("negative index %i out of range, "
+                                      "valid values are -1 through "
+                                      "-%" PRIu64,
+                                      idx, (uint64_t)array_count);
+  }
+  return OptionValueSP();
+}
+
+size_t OptionValueArray::GetArgs(Args &args) const {
+  args.Clear();
+  const uint32_t size = m_values.size();
+  for (uint32_t i = 0; i < size; ++i) {
+    llvm::StringRef string_value = m_values[i]->GetStringValue();
+    if (!string_value.empty())
+      args.AppendArgument(string_value);
+  }
+
+  return args.GetArgumentCount();
+}
+
+Status OptionValueArray::SetArgs(const Args &args, VarSetOperationType op) {
+  Status error;
+  const size_t argc = args.GetArgumentCount();
+  switch (op) {
+  case eVarSetOperationInvalid:
+    error.SetErrorString("unsupported operation");
+    break;
+
+  case eVarSetOperationInsertBefore:
+  case eVarSetOperationInsertAfter:
+    if (argc > 1) {
+      uint32_t idx =
+          StringConvert::ToUInt32(args.GetArgumentAtIndex(0), UINT32_MAX);
+      const uint32_t count = GetSize();
+      if (idx > count) {
+        error.SetErrorStringWithFormat(
+            "invalid insert array index %u, index must be 0 through %u", idx,
+            count);
+      } else {
+        if (op == eVarSetOperationInsertAfter)
+          ++idx;
+        for (size_t i = 1; i < argc; ++i, ++idx) {
+          lldb::OptionValueSP value_sp(CreateValueFromCStringForTypeMask(
+              args.GetArgumentAtIndex(i), m_type_mask, error));
+          if (value_sp) {
+            if (error.Fail())
+              return error;
+            if (idx >= m_values.size())
+              m_values.push_back(value_sp);
+            else
+              m_values.insert(m_values.begin() + idx, value_sp);
+          } else {
+            error.SetErrorString(
+                "array of complex types must subclass OptionValueArray");
+            return error;
+          }
+        }
+      }
+    } else {
+      error.SetErrorString("insert operation takes an array index followed by "
+                           "one or more values");
+    }
+    break;
+
+  case eVarSetOperationRemove:
+    if (argc > 0) {
+      const uint32_t size = m_values.size();
+      std::vector<int> remove_indexes;
+      bool all_indexes_valid = true;
+      size_t i;
+      for (i = 0; i < argc; ++i) {
+        const size_t idx =
+            StringConvert::ToSInt32(args.GetArgumentAtIndex(i), INT32_MAX);
+        if (idx >= size) {
+          all_indexes_valid = false;
+          break;
+        } else
+          remove_indexes.push_back(idx);
+      }
+
+      if (all_indexes_valid) {
+        size_t num_remove_indexes = remove_indexes.size();
+        if (num_remove_indexes) {
+          // Sort and then erase in reverse so indexes are always valid
+          if (num_remove_indexes > 1) {
+            llvm::sort(remove_indexes.begin(), remove_indexes.end());
+            for (std::vector<int>::const_reverse_iterator
+                     pos = remove_indexes.rbegin(),
+                     end = remove_indexes.rend();
+                 pos != end; ++pos) {
+              m_values.erase(m_values.begin() + *pos);
+            }
+          } else {
+            // Only one index
+            m_values.erase(m_values.begin() + remove_indexes.front());
+          }
+        }
+      } else {
+        error.SetErrorStringWithFormat(
+            "invalid array index '%s', aborting remove operation",
+            args.GetArgumentAtIndex(i));
+      }
+    } else {
+      error.SetErrorString("remove operation takes one or more array indices");
+    }
+    break;
+
+  case eVarSetOperationClear:
+    Clear();
+    break;
+
+  case eVarSetOperationReplace:
+    if (argc > 1) {
+      uint32_t idx =
+          StringConvert::ToUInt32(args.GetArgumentAtIndex(0), UINT32_MAX);
+      const uint32_t count = GetSize();
+      if (idx > count) {
+        error.SetErrorStringWithFormat(
+            "invalid replace array index %u, index must be 0 through %u", idx,
+            count);
+      } else {
+        for (size_t i = 1; i < argc; ++i, ++idx) {
+          lldb::OptionValueSP value_sp(CreateValueFromCStringForTypeMask(
+              args.GetArgumentAtIndex(i), m_type_mask, error));
+          if (value_sp) {
+            if (error.Fail())
+              return error;
+            if (idx < count)
+              m_values[idx] = value_sp;
+            else
+              m_values.push_back(value_sp);
+          } else {
+            error.SetErrorString(
+                "array of complex types must subclass OptionValueArray");
+            return error;
+          }
+        }
+      }
+    } else {
+      error.SetErrorString("replace operation takes an array index followed by "
+                           "one or more values");
+    }
+    break;
+
+  case eVarSetOperationAssign:
+    m_values.clear();
+    // Fall through to append case
+    LLVM_FALLTHROUGH;
+  case eVarSetOperationAppend:
+    for (size_t i = 0; i < argc; ++i) {
+      lldb::OptionValueSP value_sp(CreateValueFromCStringForTypeMask(
+          args.GetArgumentAtIndex(i), m_type_mask, error));
+      if (value_sp) {
+        if (error.Fail())
+          return error;
+        m_value_was_set = true;
+        AppendValue(value_sp);
+      } else {
+        error.SetErrorString(
+            "array of complex types must subclass OptionValueArray");
+      }
+    }
+    break;
+  }
+  return error;
+}
+
+lldb::OptionValueSP OptionValueArray::DeepCopy() const {
+  OptionValueArray *copied_array =
+      new OptionValueArray(m_type_mask, m_raw_value_dump);
+  lldb::OptionValueSP copied_value_sp(copied_array);
+  *static_cast<OptionValue *>(copied_array) = *this;
+  copied_array->m_callback = m_callback;
+  const uint32_t size = m_values.size();
+  for (uint32_t i = 0; i < size; ++i) {
+    copied_array->AppendValue(m_values[i]->DeepCopy());
+  }
+  return copied_value_sp;
+}