Update prebuilt Clang to r365631c1 from Android.
The version we had was segfaulting.
Bug: 132420445
Change-Id: Icb45a6fe0b4e2166f7895e669df1157cec9fb4e0
diff --git a/linux-x64/clang/include/lldb/lldb-private-enumerations.h b/linux-x64/clang/include/lldb/lldb-private-enumerations.h
new file mode 100644
index 0000000..3d8b360
--- /dev/null
+++ b/linux-x64/clang/include/lldb/lldb-private-enumerations.h
@@ -0,0 +1,264 @@
+//===-- lldb-private-enumerations.h -----------------------------*- 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
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef LLDB_lldb_private_enumerations_h_
+#define LLDB_lldb_private_enumerations_h_
+
+#include "llvm/ADT/StringRef.h"
+#include "llvm/Support/FormatProviders.h"
+#include "llvm/Support/raw_ostream.h"
+
+namespace lldb_private {
+
+// Thread Step Types
+enum StepType {
+ eStepTypeNone,
+ eStepTypeTrace, ///< Single step one instruction.
+ eStepTypeTraceOver, ///< Single step one instruction, stepping over.
+ eStepTypeInto, ///< Single step into a specified context.
+ eStepTypeOver, ///< Single step over a specified context.
+ eStepTypeOut, ///< Single step out a specified context.
+ eStepTypeScripted ///< A step type implemented by the script interpreter.
+};
+
+// Address Types
+enum AddressType {
+ eAddressTypeInvalid = 0,
+ eAddressTypeFile, ///< Address is an address as found in an object or symbol
+ /// file
+ eAddressTypeLoad, ///< Address is an address as in the current target inferior
+ /// process
+ eAddressTypeHost ///< Address is an address in the process that is running
+ /// this code
+};
+
+// Address Class
+//
+// A way of classifying an address used for disassembling and setting
+// breakpoints. Many object files can track exactly what parts of their object
+// files are code, data and other information. This is of course above and
+// beyond just looking at the section types. For example, code might contain PC
+// relative data and the object file might be able to tell us that an address
+// in code is data.
+enum class AddressClass {
+ eInvalid,
+ eUnknown,
+ eCode,
+ eCodeAlternateISA,
+ eData,
+ eDebug,
+ eRuntime
+};
+
+// Votes - Need a tri-state, yes, no, no opinion...
+enum Vote { eVoteNo = -1, eVoteNoOpinion = 0, eVoteYes = 1 };
+
+enum ArchitectureType {
+ eArchTypeInvalid,
+ eArchTypeMachO,
+ eArchTypeELF,
+ eArchTypeCOFF,
+ kNumArchTypes
+};
+
+/// Settable state variable types.
+///
+
+// typedef enum SettableVariableType
+//{
+// eSetVarTypeInt,
+// eSetVarTypeBoolean,
+// eSetVarTypeString,
+// eSetVarTypeArray,
+// eSetVarTypeDictionary,
+// eSetVarTypeEnum,
+// eSetVarTypeNone
+//} SettableVariableType;
+
+enum VarSetOperationType {
+ eVarSetOperationReplace,
+ eVarSetOperationInsertBefore,
+ eVarSetOperationInsertAfter,
+ eVarSetOperationRemove,
+ eVarSetOperationAppend,
+ eVarSetOperationClear,
+ eVarSetOperationAssign,
+ eVarSetOperationInvalid
+};
+
+enum ArgumentRepetitionType {
+ eArgRepeatPlain, // Exactly one occurrence
+ eArgRepeatOptional, // At most one occurrence, but it's optional
+ eArgRepeatPlus, // One or more occurrences
+ eArgRepeatStar, // Zero or more occurrences
+ eArgRepeatRange, // Repetition of same argument, from 1 to n
+ eArgRepeatPairPlain, // A pair of arguments that must always go together
+ // ([arg-type arg-value]), occurs exactly once
+ eArgRepeatPairOptional, // A pair that occurs at most once (optional)
+ eArgRepeatPairPlus, // One or more occurrences of a pair
+ eArgRepeatPairStar, // Zero or more occurrences of a pair
+ eArgRepeatPairRange, // A pair that repeats from 1 to n
+ eArgRepeatPairRangeOptional // A pair that repeats from 1 to n, but is
+ // optional
+};
+
+enum SortOrder { eSortOrderNone, eSortOrderByAddress, eSortOrderByName };
+
+// LazyBool is for boolean values that need to be calculated lazily. Values
+// start off set to eLazyBoolCalculate, and then they can be calculated once
+// and set to eLazyBoolNo or eLazyBoolYes.
+enum LazyBool { eLazyBoolCalculate = -1, eLazyBoolNo = 0, eLazyBoolYes = 1 };
+
+/// Instruction types
+enum InstructionType {
+ eInstructionTypeAny, // Support for any instructions at all (at least one)
+ eInstructionTypePrologueEpilogue, // All prologue and epilogue instructions
+ // that push and pop register values and
+ // modify sp/fp
+ eInstructionTypePCModifying, // Any instruction that modifies the program
+ // counter/instruction pointer
+ eInstructionTypeAll // All instructions of any kind
+
+};
+
+/// Format category entry types
+enum FormatCategoryItem {
+ eFormatCategoryItemSummary = 0x0001,
+ eFormatCategoryItemRegexSummary = 0x0002,
+ eFormatCategoryItemFilter = 0x0004,
+ eFormatCategoryItemRegexFilter = 0x0008,
+ eFormatCategoryItemSynth = 0x0010,
+ eFormatCategoryItemRegexSynth = 0x0020,
+ eFormatCategoryItemValue = 0x0040,
+ eFormatCategoryItemRegexValue = 0x0080,
+ eFormatCategoryItemValidator = 0x0100,
+ eFormatCategoryItemRegexValidator = 0x0200
+};
+
+/// Expression execution policies
+enum ExecutionPolicy {
+ eExecutionPolicyOnlyWhenNeeded,
+ eExecutionPolicyNever,
+ eExecutionPolicyAlways,
+ eExecutionPolicyTopLevel // used for top-level code
+};
+
+// Ways that the FormatManager picks a particular format for a type
+enum FormatterChoiceCriterion {
+ eFormatterChoiceCriterionDirectChoice = 0x00000000,
+ eFormatterChoiceCriterionStrippedPointerReference = 0x00000001,
+ eFormatterChoiceCriterionNavigatedTypedefs = 0x00000002,
+ eFormatterChoiceCriterionRegularExpressionSummary = 0x00000004,
+ eFormatterChoiceCriterionRegularExpressionFilter = 0x00000004,
+ eFormatterChoiceCriterionLanguagePlugin = 0x00000008,
+ eFormatterChoiceCriterionStrippedBitField = 0x00000010,
+ eFormatterChoiceCriterionWentToStaticValue = 0x00000020
+};
+
+// Synchronicity behavior of scripted commands
+enum ScriptedCommandSynchronicity {
+ eScriptedCommandSynchronicitySynchronous,
+ eScriptedCommandSynchronicityAsynchronous,
+ eScriptedCommandSynchronicityCurrentValue // use whatever the current
+ // synchronicity is
+};
+
+// Verbosity mode of "po" output
+enum LanguageRuntimeDescriptionDisplayVerbosity {
+ eLanguageRuntimeDescriptionDisplayVerbosityCompact, // only print the
+ // description string, if
+ // any
+ eLanguageRuntimeDescriptionDisplayVerbosityFull, // print the full-blown
+ // output
+};
+
+// Loading modules from memory
+enum MemoryModuleLoadLevel {
+ eMemoryModuleLoadLevelMinimal, // Load sections only
+ eMemoryModuleLoadLevelPartial, // Load function bounds but no symbols
+ eMemoryModuleLoadLevelComplete, // Load sections and all symbols
+};
+
+// Result enums for when reading multiple lines from IOHandlers
+enum class LineStatus {
+ Success, // The line that was just edited if good and should be added to the
+ // lines
+ Status, // There is an error with the current line and it needs to be
+ // re-edited
+ // before it can be accepted
+ Done // Lines are complete
+};
+
+// Boolean result of running a Type Validator
+enum class TypeValidatorResult : bool { Success = true, Failure = false };
+
+// Enumerations that can be used to specify scopes types when looking up types.
+enum class CompilerContextKind {
+ Invalid = 0,
+ TranslationUnit,
+ Module,
+ Namespace,
+ Class,
+ Structure,
+ Union,
+ Function,
+ Variable,
+ Enumeration,
+ Typedef
+};
+
+// Enumerations that can be used to specify the kind of metric we're looking at
+// when collecting stats.
+enum StatisticKind {
+ ExpressionSuccessful = 0,
+ ExpressionFailure = 1,
+ FrameVarSuccess = 2,
+ FrameVarFailure = 3,
+ StatisticMax = 4
+};
+
+
+inline std::string GetStatDescription(lldb_private::StatisticKind K) {
+ switch (K) {
+ case StatisticKind::ExpressionSuccessful:
+ return "Number of expr evaluation successes";
+ case StatisticKind::ExpressionFailure:
+ return "Number of expr evaluation failures";
+ case StatisticKind::FrameVarSuccess:
+ return "Number of frame var successes";
+ case StatisticKind::FrameVarFailure:
+ return "Number of frame var failures";
+ case StatisticKind::StatisticMax:
+ return "";
+ }
+ llvm_unreachable("Statistic not registered!");
+}
+
+} // namespace lldb_private
+
+namespace llvm {
+template <> struct format_provider<lldb_private::Vote> {
+ static void format(const lldb_private::Vote &V, llvm::raw_ostream &Stream,
+ StringRef Style) {
+ switch (V) {
+ case lldb_private::eVoteNo:
+ Stream << "no";
+ return;
+ case lldb_private::eVoteNoOpinion:
+ Stream << "no opinion";
+ return;
+ case lldb_private::eVoteYes:
+ Stream << "yes";
+ return;
+ }
+ Stream << "invalid";
+ }
+};
+}
+
+#endif // LLDB_lldb_private_enumerations_h_