Restoring authorship annotation for <shadchin@yandex-team.ru>. Commit 2 of 2.

1 files changed, 124 insertions, 124 deletions

diff --git a/contrib/libs/llvm12/include/llvm/ProfileData/InstrProfData.inc b/contrib/libs/llvm12/include/llvm/ProfileData/InstrProfData.inc
index 727723cfe1..f715505ba5 100644
--- a/contrib/libs/llvm12/include/llvm/ProfileData/InstrProfData.inc
+++ b/contrib/libs/llvm12/include/llvm/ProfileData/InstrProfData.inc
@@ -647,9 +647,9 @@ serializeValueProfDataFrom(ValueProfRecordClosure *Closure,
 /* Raw profile format version (start from 1). */
 #define INSTR_PROF_RAW_VERSION 5
 /* Indexed profile format version (start from 1). */
-#define INSTR_PROF_INDEX_VERSION 7 
+#define INSTR_PROF_INDEX_VERSION 7
 /* Coverage mapping format version (start from 0). */
-#define INSTR_PROF_COVMAP_VERSION 4 
+#define INSTR_PROF_COVMAP_VERSION 4
 
 /* Profile version is always of type uint64_t. Reserve the upper 8 bits in the
  * version for other variants of profile. We set the lowest bit of the upper 8
@@ -661,7 +661,7 @@ serializeValueProfDataFrom(ValueProfRecordClosure *Closure,
 #define GET_VERSION(V) ((V) & ~VARIANT_MASKS_ALL)
 #define VARIANT_MASK_IR_PROF (0x1ULL << 56)
 #define VARIANT_MASK_CSIR_PROF (0x1ULL << 57)
-#define VARIANT_MASK_INSTR_ENTRY (0x1ULL << 58) 
+#define VARIANT_MASK_INSTR_ENTRY (0x1ULL << 58)
 #define INSTR_PROF_RAW_VERSION_VAR __llvm_profile_raw_version
 #define INSTR_PROF_PROFILE_RUNTIME_VAR __llvm_profile_runtime
 
@@ -744,9 +744,9 @@ serializeValueProfDataFrom(ValueProfRecordClosure *Closure,
 #define INSTR_PROF_VALUE_PROF_FUNC __llvm_profile_instrument_target
 #define INSTR_PROF_VALUE_PROF_FUNC_STR \
         INSTR_PROF_QUOTE(INSTR_PROF_VALUE_PROF_FUNC)
-#define INSTR_PROF_VALUE_PROF_MEMOP_FUNC __llvm_profile_instrument_memop 
-#define INSTR_PROF_VALUE_PROF_MEMOP_FUNC_STR                                   \ 
-  INSTR_PROF_QUOTE(INSTR_PROF_VALUE_PROF_MEMOP_FUNC) 
+#define INSTR_PROF_VALUE_PROF_MEMOP_FUNC __llvm_profile_instrument_memop
+#define INSTR_PROF_VALUE_PROF_MEMOP_FUNC_STR                                   \
+  INSTR_PROF_QUOTE(INSTR_PROF_VALUE_PROF_MEMOP_FUNC)
 
 /* InstrProfile per-function control data alignment.  */
 #define INSTR_PROF_DATA_ALIGNMENT 8
@@ -774,121 +774,121 @@ typedef struct InstrProfValueData {
 #endif
 
 #undef COVMAP_V2_OR_V3
- 
-#ifdef INSTR_PROF_VALUE_PROF_MEMOP_API 
- 
-#ifdef __cplusplus 
-#define INSTR_PROF_INLINE inline 
-#else 
-#define INSTR_PROF_INLINE 
-#endif 
- 
-/* The value range buckets (22 buckets) for the memop size value profiling looks 
- * like: 
- * 
- *   [0, 0] 
- *   [1, 1] 
- *   [2, 2] 
- *   [3, 3] 
- *   [4, 4] 
- *   [5, 5] 
- *   [6, 6] 
- *   [7, 7] 
- *   [8, 8] 
- *   [9, 15] 
- *   [16, 16] 
- *   [17, 31] 
- *   [32, 32] 
- *   [33, 63] 
- *   [64, 64] 
- *   [65, 127] 
- *   [128, 128] 
- *   [129, 255] 
- *   [256, 256] 
- *   [257, 511] 
- *   [512, 512] 
- *   [513, UINT64_MAX] 
- * 
- * Each range has a 'representative value' which is the lower end value of the 
- * range and used to store in the runtime profile data records and the VP 
- * metadata. For example, it's 2 for [2, 2] and 64 for [65, 127]. 
- */ 
- 
-/* 
- * Clz and Popcount. This code was copied from 
- * compiler-rt/lib/fuzzer/{FuzzerBuiltins.h,FuzzerBuiltinsMsvc.h} and 
- * llvm/include/llvm/Support/MathExtras.h. 
- */ 
-#if defined(_MSC_VER) && !defined(__clang__) 
- 
-#include <intrin.h> 
-INSTR_PROF_VISIBILITY INSTR_PROF_INLINE 
-int InstProfClzll(unsigned long long X) { 
-  unsigned long LeadZeroIdx = 0; 
-#if !defined(_M_ARM64) && !defined(_M_X64) 
-  // Scan the high 32 bits. 
-  if (_BitScanReverse(&LeadZeroIdx, (unsigned long)(X >> 32))) 
-    return (int)(63 - (LeadZeroIdx + 32)); // Create a bit offset 
-                                                      // from the MSB. 
-  // Scan the low 32 bits. 
-  if (_BitScanReverse(&LeadZeroIdx, (unsigned long)(X))) 
-    return (int)(63 - LeadZeroIdx); 
-#else 
-  if (_BitScanReverse64(&LeadZeroIdx, X)) return 63 - LeadZeroIdx; 
-#endif 
-  return 64; 
-} 
-INSTR_PROF_VISIBILITY INSTR_PROF_INLINE 
-int InstProfPopcountll(unsigned long long X) { 
-  // This code originates from https://reviews.llvm.org/rG30626254510f. 
-  unsigned long long v = X; 
-  v = v - ((v >> 1) & 0x5555555555555555ULL); 
-  v = (v & 0x3333333333333333ULL) + ((v >> 2) & 0x3333333333333333ULL); 
-  v = (v + (v >> 4)) & 0x0F0F0F0F0F0F0F0FULL; 
-  return (int)((unsigned long long)(v * 0x0101010101010101ULL) >> 56); 
-} 
- 
-#else 
- 
-INSTR_PROF_VISIBILITY INSTR_PROF_INLINE 
-int InstProfClzll(unsigned long long X) { return __builtin_clzll(X); } 
-INSTR_PROF_VISIBILITY INSTR_PROF_INLINE 
-int InstProfPopcountll(unsigned long long X) { return __builtin_popcountll(X); } 
- 
-#endif  /* defined(_MSC_VER) && !defined(__clang__) */ 
- 
-/* Map an (observed) memop size value to the representative value of its range. 
- * For example, 5 -> 5, 22 -> 17, 99 -> 65, 256 -> 256, 1001 -> 513. */ 
-INSTR_PROF_VISIBILITY INSTR_PROF_INLINE uint64_t 
-InstrProfGetRangeRepValue(uint64_t Value) { 
-  if (Value <= 8) 
-    // The first ranges are individually tracked. Use the value as is. 
-    return Value; 
-  else if (Value >= 513) 
-    // The last range is mapped to its lowest value. 
-    return 513; 
-  else if (InstProfPopcountll(Value) == 1) 
-    // If it's a power of two, use it as is. 
-    return Value; 
-  else 
-    // Otherwise, take to the previous power of two + 1. 
-    return (1 << (64 - InstProfClzll(Value) - 1)) + 1; 
-} 
- 
-/* Return true if the range that an (observed) memop size value belongs to has 
- * only a single value in the range.  For example, 0 -> true, 8 -> true, 10 -> 
- * false, 64 -> true, 100 -> false, 513 -> false. */ 
-INSTR_PROF_VISIBILITY INSTR_PROF_INLINE unsigned 
-InstrProfIsSingleValRange(uint64_t Value) { 
-  if (Value <= 8) 
-    // The first ranges are individually tracked. 
-    return 1; 
-  else if (InstProfPopcountll(Value) == 1) 
-    // If it's a power of two, there's only one value. 
-    return 1; 
-  else 
-    // Otherwise, there's more than one value in the range. 
-    return 0; 
-} 
- 
-#endif /* INSTR_PROF_VALUE_PROF_MEMOP_API */ 
+
+#ifdef INSTR_PROF_VALUE_PROF_MEMOP_API
+
+#ifdef __cplusplus
+#define INSTR_PROF_INLINE inline
+#else
+#define INSTR_PROF_INLINE
+#endif
+
+/* The value range buckets (22 buckets) for the memop size value profiling looks
+ * like:
+ *
+ *   [0, 0]
+ *   [1, 1]
+ *   [2, 2]
+ *   [3, 3]
+ *   [4, 4]
+ *   [5, 5]
+ *   [6, 6]
+ *   [7, 7]
+ *   [8, 8]
+ *   [9, 15]
+ *   [16, 16]
+ *   [17, 31]
+ *   [32, 32]
+ *   [33, 63]
+ *   [64, 64]
+ *   [65, 127]
+ *   [128, 128]
+ *   [129, 255]
+ *   [256, 256]
+ *   [257, 511]
+ *   [512, 512]
+ *   [513, UINT64_MAX]
+ *
+ * Each range has a 'representative value' which is the lower end value of the
+ * range and used to store in the runtime profile data records and the VP
+ * metadata. For example, it's 2 for [2, 2] and 64 for [65, 127].
+ */
+
+/*
+ * Clz and Popcount. This code was copied from
+ * compiler-rt/lib/fuzzer/{FuzzerBuiltins.h,FuzzerBuiltinsMsvc.h} and
+ * llvm/include/llvm/Support/MathExtras.h.
+ */
+#if defined(_MSC_VER) && !defined(__clang__)
+
+#include <intrin.h>
+INSTR_PROF_VISIBILITY INSTR_PROF_INLINE
+int InstProfClzll(unsigned long long X) {
+  unsigned long LeadZeroIdx = 0;
+#if !defined(_M_ARM64) && !defined(_M_X64)
+  // Scan the high 32 bits.
+  if (_BitScanReverse(&LeadZeroIdx, (unsigned long)(X >> 32)))
+    return (int)(63 - (LeadZeroIdx + 32)); // Create a bit offset
+                                                      // from the MSB.
+  // Scan the low 32 bits.
+  if (_BitScanReverse(&LeadZeroIdx, (unsigned long)(X)))
+    return (int)(63 - LeadZeroIdx);
+#else
+  if (_BitScanReverse64(&LeadZeroIdx, X)) return 63 - LeadZeroIdx;
+#endif
+  return 64;
+}
+INSTR_PROF_VISIBILITY INSTR_PROF_INLINE
+int InstProfPopcountll(unsigned long long X) {
+  // This code originates from https://reviews.llvm.org/rG30626254510f.
+  unsigned long long v = X;
+  v = v - ((v >> 1) & 0x5555555555555555ULL);
+  v = (v & 0x3333333333333333ULL) + ((v >> 2) & 0x3333333333333333ULL);
+  v = (v + (v >> 4)) & 0x0F0F0F0F0F0F0F0FULL;
+  return (int)((unsigned long long)(v * 0x0101010101010101ULL) >> 56);
+}
+
+#else
+
+INSTR_PROF_VISIBILITY INSTR_PROF_INLINE
+int InstProfClzll(unsigned long long X) { return __builtin_clzll(X); }
+INSTR_PROF_VISIBILITY INSTR_PROF_INLINE
+int InstProfPopcountll(unsigned long long X) { return __builtin_popcountll(X); }
+
+#endif  /* defined(_MSC_VER) && !defined(__clang__) */
+
+/* Map an (observed) memop size value to the representative value of its range.
+ * For example, 5 -> 5, 22 -> 17, 99 -> 65, 256 -> 256, 1001 -> 513. */
+INSTR_PROF_VISIBILITY INSTR_PROF_INLINE uint64_t
+InstrProfGetRangeRepValue(uint64_t Value) {
+  if (Value <= 8)
+    // The first ranges are individually tracked. Use the value as is.
+    return Value;
+  else if (Value >= 513)
+    // The last range is mapped to its lowest value.
+    return 513;
+  else if (InstProfPopcountll(Value) == 1)
+    // If it's a power of two, use it as is.
+    return Value;
+  else
+    // Otherwise, take to the previous power of two + 1.
+    return (1 << (64 - InstProfClzll(Value) - 1)) + 1;
+}
+
+/* Return true if the range that an (observed) memop size value belongs to has
+ * only a single value in the range.  For example, 0 -> true, 8 -> true, 10 ->
+ * false, 64 -> true, 100 -> false, 513 -> false. */
+INSTR_PROF_VISIBILITY INSTR_PROF_INLINE unsigned
+InstrProfIsSingleValRange(uint64_t Value) {
+  if (Value <= 8)
+    // The first ranges are individually tracked.
+    return 1;
+  else if (InstProfPopcountll(Value) == 1)
+    // If it's a power of two, there's only one value.
+    return 1;
+  else
+    // Otherwise, there's more than one value in the range.
+    return 0;
+}
+
+#endif /* INSTR_PROF_VALUE_PROF_MEMOP_API */