From 6ffe9e53658409f212834330e13564e4952558f6 Mon Sep 17 00:00:00 2001
From: vitalyisaev <vitalyisaev@yandex-team.com>
Date: Thu, 29 Jun 2023 10:00:50 +0300
Subject: YQ Connector: support managed ClickHouse
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit
Со стороны dqrun можно обратиться к инстансу коннектора, который работает на streaming стенде, и извлечь данные из облачного CH.
---
contrib/libs/llvm14/lib/BinaryFormat/XCOFF.cpp | 277 +++++++++++++++++++++++++
1 file changed, 277 insertions(+)
create mode 100644 contrib/libs/llvm14/lib/BinaryFormat/XCOFF.cpp
(limited to 'contrib/libs/llvm14/lib/BinaryFormat/XCOFF.cpp')
diff --git a/contrib/libs/llvm14/lib/BinaryFormat/XCOFF.cpp b/contrib/libs/llvm14/lib/BinaryFormat/XCOFF.cpp
new file mode 100644
index 0000000000..6b11ab2ff9
--- /dev/null
+++ b/contrib/libs/llvm14/lib/BinaryFormat/XCOFF.cpp
@@ -0,0 +1,277 @@
+//===-- llvm/BinaryFormat/XCOFF.cpp - The XCOFF file format -----*- 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 "llvm/BinaryFormat/XCOFF.h"
+#include "llvm/ADT/SmallString.h"
+#include "llvm/ADT/StringRef.h"
+#include "llvm/Support/Errc.h"
+#include "llvm/Support/Error.h"
+
+using namespace llvm;
+
+#define SMC_CASE(A) \
+ case XCOFF::XMC_##A: \
+ return #A;
+StringRef XCOFF::getMappingClassString(XCOFF::StorageMappingClass SMC) {
+ switch (SMC) {
+ SMC_CASE(PR)
+ SMC_CASE(RO)
+ SMC_CASE(DB)
+ SMC_CASE(GL)
+ SMC_CASE(XO)
+ SMC_CASE(SV)
+ SMC_CASE(SV64)
+ SMC_CASE(SV3264)
+ SMC_CASE(TI)
+ SMC_CASE(TB)
+ SMC_CASE(RW)
+ SMC_CASE(TC0)
+ SMC_CASE(TC)
+ SMC_CASE(TD)
+ SMC_CASE(DS)
+ SMC_CASE(UA)
+ SMC_CASE(BS)
+ SMC_CASE(UC)
+ SMC_CASE(TL)
+ SMC_CASE(UL)
+ SMC_CASE(TE)
+#undef SMC_CASE
+ }
+
+ // TODO: need to add a test case for "Unknown" and other SMC.
+ return "Unknown";
+}
+
+#define RELOC_CASE(A) \
+ case XCOFF::A: \
+ return #A;
+StringRef XCOFF::getRelocationTypeString(XCOFF::RelocationType Type) {
+ switch (Type) {
+ RELOC_CASE(R_POS)
+ RELOC_CASE(R_RL)
+ RELOC_CASE(R_RLA)
+ RELOC_CASE(R_NEG)
+ RELOC_CASE(R_REL)
+ RELOC_CASE(R_TOC)
+ RELOC_CASE(R_TRL)
+ RELOC_CASE(R_TRLA)
+ RELOC_CASE(R_GL)
+ RELOC_CASE(R_TCL)
+ RELOC_CASE(R_REF)
+ RELOC_CASE(R_BA)
+ RELOC_CASE(R_BR)
+ RELOC_CASE(R_RBA)
+ RELOC_CASE(R_RBR)
+ RELOC_CASE(R_TLS)
+ RELOC_CASE(R_TLS_IE)
+ RELOC_CASE(R_TLS_LD)
+ RELOC_CASE(R_TLS_LE)
+ RELOC_CASE(R_TLSM)
+ RELOC_CASE(R_TLSML)
+ RELOC_CASE(R_TOCU)
+ RELOC_CASE(R_TOCL)
+ }
+ return "Unknown";
+}
+#undef RELOC_CASE
+
+#define LANG_CASE(A) \
+ case XCOFF::TracebackTable::A: \
+ return #A;
+
+StringRef XCOFF::getNameForTracebackTableLanguageId(
+ XCOFF::TracebackTable::LanguageID LangId) {
+ switch (LangId) {
+ LANG_CASE(C)
+ LANG_CASE(Fortran)
+ LANG_CASE(Pascal)
+ LANG_CASE(Ada)
+ LANG_CASE(PL1)
+ LANG_CASE(Basic)
+ LANG_CASE(Lisp)
+ LANG_CASE(Cobol)
+ LANG_CASE(Modula2)
+ LANG_CASE(Rpg)
+ LANG_CASE(PL8)
+ LANG_CASE(Assembly)
+ LANG_CASE(Java)
+ LANG_CASE(ObjectiveC)
+ LANG_CASE(CPlusPlus)
+ }
+ return "Unknown";
+}
+#undef LANG_CASE
+
+Expected<SmallString<32>> XCOFF::parseParmsType(uint32_t Value,
+ unsigned FixedParmsNum,
+ unsigned FloatingParmsNum) {
+ SmallString<32> ParmsType;
+ int Bits = 0;
+ unsigned ParsedFixedNum = 0;
+ unsigned ParsedFloatingNum = 0;
+ unsigned ParsedNum = 0;
+ unsigned ParmsNum = FixedParmsNum + FloatingParmsNum;
+
+ // In the function PPCFunctionInfo::getParmsType(), when there are no vector
+ // parameters, the 31st bit of ParmsType is always zero even if it indicates a
+ // floating point parameter. The parameter type information is lost. There
+ // are only 8 GPRs used for parameters passing, the floating parameters
+ // also occupy GPRs if there are available, so the 31st bit can never be a
+ // fixed parameter. At the same time, we also do not know whether the zero of
+ // the 31st bit indicates a float or double parameter type here. Therefore, we
+ // ignore the 31st bit.
+ while (Bits < 31 && ParsedNum < ParmsNum) {
+ if (++ParsedNum > 1)
+ ParmsType += ", ";
+ if ((Value & TracebackTable::ParmTypeIsFloatingBit) == 0) {
+ // Fixed parameter type.
+ ParmsType += "i";
+ ++ParsedFixedNum;
+ Value <<= 1;
+ ++Bits;
+ } else {
+ if ((Value & TracebackTable::ParmTypeFloatingIsDoubleBit) == 0)
+ // Float parameter type.
+ ParmsType += "f";
+ else
+ // Double parameter type.
+ ParmsType += "d";
+ ++ParsedFloatingNum;
+ Value <<= 2;
+ Bits += 2;
+ }
+ }
+
+ // We have more parameters than the 32 Bits could encode.
+ if (ParsedNum < ParmsNum)
+ ParmsType += ", ...";
+
+ if (Value != 0u || ParsedFixedNum > FixedParmsNum ||
+ ParsedFloatingNum > FloatingParmsNum)
+ return createStringError(errc::invalid_argument,
+ "ParmsType encodes can not map to ParmsNum "
+ "parameters in parseParmsType.");
+ return ParmsType;
+}
+
+SmallString<32> XCOFF::getExtendedTBTableFlagString(uint8_t Flag) {
+ SmallString<32> Res;
+
+ if (Flag & ExtendedTBTableFlag::TB_OS1)
+ Res += "TB_OS1 ";
+ if (Flag & ExtendedTBTableFlag::TB_RESERVED)
+ Res += "TB_RESERVED ";
+ if (Flag & ExtendedTBTableFlag::TB_SSP_CANARY)
+ Res += "TB_SSP_CANARY ";
+ if (Flag & ExtendedTBTableFlag::TB_OS2)
+ Res += "TB_OS2 ";
+ if (Flag & ExtendedTBTableFlag::TB_EH_INFO)
+ Res += "TB_EH_INFO ";
+ if (Flag & ExtendedTBTableFlag::TB_LONGTBTABLE2)
+ Res += "TB_LONGTBTABLE2 ";
+
+ // Two of the bits that haven't got used in the mask.
+ if (Flag & 0x06)
+ Res += "Unknown ";
+
+ // Pop the last space.
+ Res.pop_back();
+ return Res;
+}
+
+Expected<SmallString<32>>
+XCOFF::parseParmsTypeWithVecInfo(uint32_t Value, unsigned FixedParmsNum,
+ unsigned FloatingParmsNum,
+ unsigned VectorParmsNum) {
+ SmallString<32> ParmsType;
+
+ unsigned ParsedFixedNum = 0;
+ unsigned ParsedFloatingNum = 0;
+ unsigned ParsedVectorNum = 0;
+ unsigned ParsedNum = 0;
+ unsigned ParmsNum = FixedParmsNum + FloatingParmsNum + VectorParmsNum;
+
+ for (int Bits = 0; Bits < 32 && ParsedNum < ParmsNum; Bits += 2) {
+ if (++ParsedNum > 1)
+ ParmsType += ", ";
+
+ switch (Value & TracebackTable::ParmTypeMask) {
+ case TracebackTable::ParmTypeIsFixedBits:
+ ParmsType += "i";
+ ++ParsedFixedNum;
+ break;
+ case TracebackTable::ParmTypeIsVectorBits:
+ ParmsType += "v";
+ ++ParsedVectorNum;
+ break;
+ case TracebackTable::ParmTypeIsFloatingBits:
+ ParmsType += "f";
+ ++ParsedFloatingNum;
+ break;
+ case TracebackTable::ParmTypeIsDoubleBits:
+ ParmsType += "d";
+ ++ParsedFloatingNum;
+ break;
+ default:
+ assert(false && "Unrecognized bits in ParmsType.");
+ }
+ Value <<= 2;
+ }
+
+ // We have more parameters than the 32 Bits could encode.
+ if (ParsedNum < ParmsNum)
+ ParmsType += ", ...";
+
+ if (Value != 0u || ParsedFixedNum > FixedParmsNum ||
+ ParsedFloatingNum > FloatingParmsNum || ParsedVectorNum > VectorParmsNum)
+ return createStringError(
+ errc::invalid_argument,
+ "ParmsType encodes can not map to ParmsNum parameters "
+ "in parseParmsTypeWithVecInfo.");
+
+ return ParmsType;
+}
+
+Expected<SmallString<32>> XCOFF::parseVectorParmsType(uint32_t Value,
+ unsigned ParmsNum) {
+ SmallString<32> ParmsType;
+ unsigned ParsedNum = 0;
+ for (int Bits = 0; ParsedNum < ParmsNum && Bits < 32; Bits += 2) {
+ if (++ParsedNum > 1)
+ ParmsType += ", ";
+ switch (Value & TracebackTable::ParmTypeMask) {
+ case TracebackTable::ParmTypeIsVectorCharBit:
+ ParmsType += "vc";
+ break;
+
+ case TracebackTable::ParmTypeIsVectorShortBit:
+ ParmsType += "vs";
+ break;
+
+ case TracebackTable::ParmTypeIsVectorIntBit:
+ ParmsType += "vi";
+ break;
+
+ case TracebackTable::ParmTypeIsVectorFloatBit:
+ ParmsType += "vf";
+ break;
+ }
+
+ Value <<= 2;
+ }
+
+ // We have more parameters than the 32 Bits could encode.
+ if (ParsedNum < ParmsNum)
+ ParmsType += ", ...";
+
+ if (Value != 0u)
+ return createStringError(errc::invalid_argument,
+ "ParmsType encodes more than ParmsNum parameters "
+ "in parseVectorParmsType.");
+ return ParmsType;
+}
--
cgit v1.2.3