Update prebuilt Clang to r370808.

clang 10.0.1 (based on r370808) from build 6016109.

Bug: http://b/139945549
Test: N/A
Change-Id: Ie40b5bad50b89e3bc4f52dcedc911b7fd2f5beb6

1 files changed, 132 insertions, 0 deletions

diff --git a/clang-r370808/include/llvm/DebugInfo/Symbolize/Symbolize.h b/clang-r370808/include/llvm/DebugInfo/Symbolize/Symbolize.h
new file mode 100644
index 00000000..11599fc1
--- /dev/null
+++ b/clang-r370808/include/llvm/DebugInfo/Symbolize/Symbolize.h
@@ -0,0 +1,132 @@
+//===- Symbolize.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
+//
+//===----------------------------------------------------------------------===//
+//
+// Header for LLVM symbolization library.
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef LLVM_DEBUGINFO_SYMBOLIZE_SYMBOLIZE_H
+#define LLVM_DEBUGINFO_SYMBOLIZE_SYMBOLIZE_H
+
+#include "llvm/DebugInfo/Symbolize/SymbolizableModule.h"
+#include "llvm/Object/Binary.h"
+#include "llvm/Object/ObjectFile.h"
+#include "llvm/Support/Error.h"
+#include <algorithm>
+#include <cstdint>
+#include <map>
+#include <memory>
+#include <string>
+#include <utility>
+#include <vector>
+
+namespace llvm {
+namespace symbolize {
+
+using namespace object;
+
+using FunctionNameKind = DILineInfoSpecifier::FunctionNameKind;
+
+class LLVMSymbolizer {
+public:
+  struct Options {
+    FunctionNameKind PrintFunctions = FunctionNameKind::LinkageName;
+    bool UseSymbolTable = true;
+    bool Demangle = true;
+    bool RelativeAddresses = false;
+    bool UntagAddresses = false;
+    std::string DefaultArch;
+    std::vector<std::string> DsymHints;
+    std::string FallbackDebugPath;
+    std::string DWPName;
+  };
+
+  LLVMSymbolizer() = default;
+  LLVMSymbolizer(const Options &Opts) : Opts(Opts) {}
+
+  ~LLVMSymbolizer() {
+    flush();
+  }
+
+  Expected<DILineInfo> symbolizeCode(const ObjectFile &Obj,
+                                     object::SectionedAddress ModuleOffset);
+  Expected<DILineInfo> symbolizeCode(const std::string &ModuleName,
+                                     object::SectionedAddress ModuleOffset);
+  Expected<DIInliningInfo>
+  symbolizeInlinedCode(const std::string &ModuleName,
+                       object::SectionedAddress ModuleOffset);
+  Expected<DIGlobal> symbolizeData(const std::string &ModuleName,
+                                   object::SectionedAddress ModuleOffset);
+  Expected<std::vector<DILocal>>
+  symbolizeFrame(const std::string &ModuleName,
+                 object::SectionedAddress ModuleOffset);
+  void flush();
+
+  static std::string
+  DemangleName(const std::string &Name,
+               const SymbolizableModule *DbiModuleDescriptor);
+
+private:
+  // Bundles together object file with code/data and object file with
+  // corresponding debug info. These objects can be the same.
+  using ObjectPair = std::pair<const ObjectFile *, const ObjectFile *>;
+
+  Expected<DILineInfo>
+  symbolizeCodeCommon(SymbolizableModule *Info,
+                      object::SectionedAddress ModuleOffset);
+
+  /// Returns a SymbolizableModule or an error if loading debug info failed.
+  /// Only one attempt is made to load a module, and errors during loading are
+  /// only reported once. Subsequent calls to get module info for a module that
+  /// failed to load will return nullptr.
+  Expected<SymbolizableModule *>
+  getOrCreateModuleInfo(const std::string &ModuleName);
+
+  Expected<SymbolizableModule *>
+  createModuleInfo(const ObjectFile *Obj,
+                   std::unique_ptr<DIContext> Context,
+                   StringRef ModuleName);
+
+  ObjectFile *lookUpDsymFile(const std::string &Path,
+                             const MachOObjectFile *ExeObj,
+                             const std::string &ArchName);
+  ObjectFile *lookUpDebuglinkObject(const std::string &Path,
+                                    const ObjectFile *Obj,
+                                    const std::string &ArchName);
+
+  /// Returns pair of pointers to object and debug object.
+  Expected<ObjectPair> getOrCreateObjectPair(const std::string &Path,
+                                            const std::string &ArchName);
+
+  /// Return a pointer to object file at specified path, for a specified
+  /// architecture (e.g. if path refers to a Mach-O universal binary, only one
+  /// object file from it will be returned).
+  Expected<ObjectFile *> getOrCreateObject(const std::string &Path,
+                                          const std::string &ArchName);
+
+  std::map<std::string, std::unique_ptr<SymbolizableModule>> Modules;
+
+  /// Contains cached results of getOrCreateObjectPair().
+  std::map<std::pair<std::string, std::string>, ObjectPair>
+      ObjectPairForPathArch;
+
+  /// Contains parsed binary for each path, or parsing error.
+  std::map<std::string, OwningBinary<Binary>> BinaryForPath;
+
+  /// Parsed object file for path/architecture pair, where "path" refers
+  /// to Mach-O universal binary.
+  std::map<std::pair<std::string, std::string>, std::unique_ptr<ObjectFile>>
+      ObjectForUBPathAndArch;
+
+  Options Opts;
+};
+
+} // end namespace symbolize
+} // end namespace llvm
+
+#endif // LLVM_DEBUGINFO_SYMBOLIZE_SYMBOLIZE_H