File Manager

003 File Manager

Current Path: /usr/src/contrib/llvm-project/clang/include/clang/Basic

usr / src / contrib / llvm-project / clang / include / clang / Basic /

📁 ..
📄 AArch64SVEACLETypes.def(7.09 KB)
📄 ABI.h(5.95 KB)
📄 ASTNode.td(120 B)
📄 AddressSpaces.h(2.59 KB)
📄 AlignedAllocation.h(1.38 KB)
📄 AllDiagnostics.h(1.44 KB)
📄 Attr.td(122.78 KB)
📄 AttrDocs.td(197.8 KB)
📄 AttrKinds.h(929 B)
📄 AttrSubjectMatchRules.h(957 B)
📄 AttributeCommonInfo.h(7.02 KB)
📄 Attributes.h(1.35 KB)
📄 BitmaskEnum.h(749 B)
📄 Builtins.def(71.64 KB)
📄 Builtins.h(9.13 KB)
📄 BuiltinsAArch64.def(14.31 KB)
📄 BuiltinsAMDGPU.def(13.1 KB)
📄 BuiltinsARM.def(18.6 KB)
📄 BuiltinsBPF.def(1016 B)
📄 BuiltinsHexagon.def(6.15 KB)
📄 BuiltinsHexagonDep.def(117.26 KB)
📄 BuiltinsHexagonMapCustomDep.def(8.56 KB)
📄 BuiltinsLe64.def(728 B)
📄 BuiltinsMips.def(35.51 KB)
📄 BuiltinsNEON.def(814 B)
📄 BuiltinsNVPTX.def(27.63 KB)
📄 BuiltinsPPC.def(21.53 KB)
📄 BuiltinsSVE.def(786 B)
📄 BuiltinsSystemZ.def(19.7 KB)
📄 BuiltinsWebAssembly.def(10.17 KB)
📄 BuiltinsX86.def(140.49 KB)
📄 BuiltinsX86_64.def(6.79 KB)
📄 BuiltinsXCore.def(846 B)
📄 CapturedStmt.h(662 B)
📄 CharInfo.h(6.52 KB)
📄 CodeGenOptions.def(21.65 KB)
📄 CodeGenOptions.h(14.14 KB)
📄 CommentNodes.td(1.04 KB)
📄 CommentOptions.h(1.1 KB)
📄 Cuda.h(2.3 KB)
📄 DebugInfoOptions.h(1.72 KB)
📄 DeclNodes.td(4.72 KB)
📄 Diagnostic.h(55.73 KB)
📄 Diagnostic.td(5.29 KB)
📄 DiagnosticAST.h(903 B)
📄 DiagnosticASTKinds.td(29.35 KB)
📄 DiagnosticAnalysis.h(933 B)
📄 DiagnosticAnalysisKinds.td(405 B)
📄 DiagnosticCategories.h(757 B)
📄 DiagnosticCategories.td(480 B)
📄 DiagnosticComment.h(927 B)
📄 DiagnosticCommentKinds.td(6.18 KB)
📄 DiagnosticCommonKinds.td(14.32 KB)
📄 DiagnosticCrossTU.h(927 B)
📄 DiagnosticCrossTUKinds.td(889 B)
📄 DiagnosticDocs.td(1.96 KB)
📄 DiagnosticDriver.h(921 B)
📄 DiagnosticDriverKinds.td(25.54 KB)
📄 DiagnosticError.h(1.98 KB)
📄 DiagnosticFrontend.h(933 B)
📄 DiagnosticFrontendKinds.td(13.86 KB)
📄 DiagnosticGroups.td(59.71 KB)
📄 DiagnosticIDs.h(12.83 KB)
📄 DiagnosticLex.h(903 B)
📄 DiagnosticLexKinds.td(38.36 KB)
📄 DiagnosticOptions.def(4.58 KB)
📄 DiagnosticOptions.h(4.21 KB)
📄 DiagnosticParse.h(915 B)
📄 DiagnosticParseKinds.td(68.47 KB)
📄 DiagnosticRefactoring.h(951 B)
📄 DiagnosticRefactoringKinds.td(1.33 KB)
📄 DiagnosticSema.h(909 B)
📄 DiagnosticSemaKinds.td(546.17 KB)
📄 DiagnosticSerialization.h(962 B)
📄 DiagnosticSerializationKinds.td(18.08 KB)
📄 ExceptionSpecificationType.h(2.48 KB)
📄 ExpressionTraits.h(1.18 KB)
📄 FPOptions.def(1.16 KB)
📄 Features.def(11.55 KB)
📄 FileManager.h(16.39 KB)
📄 FileSystemOptions.h(924 B)
📄 FileSystemStatCache.h(3.26 KB)
📄 FixedPoint.h(8.6 KB)
📄 IdentifierTable.h(33.75 KB)
📄 JsonSupport.h(3.69 KB)
📄 LLVM.h(2.43 KB)
📄 Lambda.h(1.37 KB)
📄 LangOptions.def(21.96 KB)
📄 LangOptions.h(18.78 KB)
📄 LangStandard.h(3.87 KB)
📄 LangStandards.def(6.8 KB)
📄 Linkage.h(4.13 KB)
📄 MSP430Target.def(7.04 KB)
📄 MacroBuilder.h(1.34 KB)
📄 Module.h(24.09 KB)
📄 ObjCRuntime.h(14.36 KB)
📄 OpenCLExtensionTypes.def(1.59 KB)
📄 OpenCLExtensions.def(4.38 KB)
📄 OpenCLImageTypes.def(4.1 KB)
📄 OpenCLOptions.h(4.42 KB)
📄 OpenMPKinds.def(4.58 KB)
📄 OpenMPKinds.h(9.66 KB)
📄 OperatorKinds.def(6.56 KB)
📄 OperatorKinds.h(1.55 KB)
📄 OperatorPrecedence.h(1.82 KB)
📄 PartialDiagnostic.h(12.96 KB)
📄 PlistSupport.h(4.02 KB)
📄 PragmaKinds.h(1.21 KB)
📄 PrettyStackTrace.h(1.26 KB)
📄 SanitizerBlacklist.h(1.73 KB)
📄 SanitizerSpecialCaseList.h(1.81 KB)
📄 Sanitizers.def(6.41 KB)
📄 Sanitizers.h(6.57 KB)
📄 SourceLocation.h(15.56 KB)
📄 SourceManager.h(71.11 KB)
📄 SourceManagerInternals.h(4.27 KB)
📄 Specifiers.h(12.68 KB)
📄 Stack.h(1.94 KB)
📄 StmtNodes.td(10.92 KB)
📄 SyncScope.h(4.87 KB)
📄 TargetBuiltins.h(9.18 KB)
📄 TargetCXXABI.h(12.49 KB)
📄 TargetInfo.h(54.4 KB)
📄 TargetOptions.h(3 KB)
📄 TemplateKinds.h(2.22 KB)
📄 TokenKinds.def(33.83 KB)
📄 TokenKinds.h(3.99 KB)
📄 TypeNodes.td(5.48 KB)
📄 TypeTraits.h(2.67 KB)
📄 Version.h(2.23 KB)
📄 Visibility.h(4.4 KB)
📄 X86Target.def(5.21 KB)
📄 XRayInstr.h(1.92 KB)
📄 XRayLists.h(1.73 KB)
📄 arm_bf16.td(590 B)
📄 arm_cde.td(9.29 KB)
📄 arm_fp16.td(5.79 KB)
📄 arm_mve.td(70.85 KB)
📄 arm_mve_defs.td(24.52 KB)
📄 arm_neon.td(90.63 KB)
📄 arm_neon_incl.td(13.64 KB)
📄 arm_sve.td(162.48 KB)

Editing: Sanitizers.h

//===- Sanitizers.h - C Language Family Language Options --------*- 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
//
//===----------------------------------------------------------------------===//
//
/// \file
/// Defines the clang::SanitizerKind enum.
//
//===----------------------------------------------------------------------===//

#ifndef LLVM_CLANG_BASIC_SANITIZERS_H
#define LLVM_CLANG_BASIC_SANITIZERS_H

#include "clang/Basic/LLVM.h"
#include "llvm/ADT/StringRef.h"
#include "llvm/Support/MathExtras.h"
#include <cassert>
#include <cstdint>

namespace llvm {
class hash_code;
}

namespace clang {

class SanitizerMask {
  // NOTE: this class assumes kNumElem == 2 in most of the constexpr functions,
  // in order to work within the C++11 constexpr function constraints. If you
  // change kNumElem, you'll need to update those member functions as well.

/// Number of array elements.
  static constexpr unsigned kNumElem = 2;
  /// Mask value initialized to 0.
  uint64_t maskLoToHigh[kNumElem]{};
  /// Number of bits in a mask.
  static constexpr unsigned kNumBits = sizeof(decltype(maskLoToHigh)) * 8;
  /// Number of bits in a mask element.
  static constexpr unsigned kNumBitElem = sizeof(decltype(maskLoToHigh[0])) * 8;

constexpr SanitizerMask(uint64_t mask1, uint64_t mask2)
      : maskLoToHigh{mask1, mask2} {}

public:
  SanitizerMask() = default;

static constexpr bool checkBitPos(const unsigned Pos) {
    return Pos < kNumBits;
  }

/// Create a mask with a bit enabled at position Pos.
  static constexpr SanitizerMask bitPosToMask(const unsigned Pos) {
    uint64_t mask1 = (Pos < kNumBitElem) ? 1ULL << (Pos % kNumBitElem) : 0;
    uint64_t mask2 = (Pos >= kNumBitElem && Pos < (kNumBitElem * 2))
                         ? 1ULL << (Pos % kNumBitElem)
                         : 0;
    return SanitizerMask(mask1, mask2);
  }

unsigned countPopulation() const {
    unsigned total = 0;
    for (const auto &Val : maskLoToHigh)
      total += llvm::countPopulation(Val);
    return total;
  }

void flipAllBits() {
    for (auto &Val : maskLoToHigh)
      Val = ~Val;
  }

bool isPowerOf2() const {
    return countPopulation() == 1;
  }

llvm::hash_code hash_value() const;

constexpr explicit operator bool() const {
    return maskLoToHigh[0] || maskLoToHigh[1];
  }

constexpr bool operator==(const SanitizerMask &V) const {
    return maskLoToHigh[0] == V.maskLoToHigh[0] &&
           maskLoToHigh[1] == V.maskLoToHigh[1];
  }

SanitizerMask &operator&=(const SanitizerMask &RHS) {
    for (unsigned k = 0; k < kNumElem; k++)
      maskLoToHigh[k] &= RHS.maskLoToHigh[k];
    return *this;
  }

SanitizerMask &operator|=(const SanitizerMask &RHS) {
    for (unsigned k = 0; k < kNumElem; k++)
      maskLoToHigh[k] |= RHS.maskLoToHigh[k];
    return *this;
  }

constexpr bool operator!() const { return !bool(*this); }

constexpr bool operator!=(const SanitizerMask &RHS) const {
    return !((*this) == RHS);
  }

friend constexpr inline SanitizerMask operator~(SanitizerMask v) {
    return SanitizerMask(~v.maskLoToHigh[0], ~v.maskLoToHigh[1]);
  }

friend constexpr inline SanitizerMask operator&(SanitizerMask a,
                                                  const SanitizerMask &b) {
    return SanitizerMask(a.maskLoToHigh[0] & b.maskLoToHigh[0],
                         a.maskLoToHigh[1] & b.maskLoToHigh[1]);
  }

friend constexpr inline SanitizerMask operator|(SanitizerMask a,
                                                  const SanitizerMask &b) {
    return SanitizerMask(a.maskLoToHigh[0] | b.maskLoToHigh[0],
                         a.maskLoToHigh[1] | b.maskLoToHigh[1]);
  }
};

// Declaring in clang namespace so that it can be found by ADL.
llvm::hash_code hash_value(const clang::SanitizerMask &Arg);

// Define the set of sanitizer kinds, as well as the set of sanitizers each
// sanitizer group expands into.
struct SanitizerKind {
  // Assign ordinals to possible values of -fsanitize= flag, which we will use
  // as bit positions.
  enum SanitizerOrdinal : uint64_t {
#define SANITIZER(NAME, ID) SO_##ID,
#define SANITIZER_GROUP(NAME, ID, ALIAS) SO_##ID##Group,
#include "clang/Basic/Sanitizers.def"
    SO_Count
  };

#define SANITIZER(NAME, ID)                                                    \
  static constexpr SanitizerMask ID = SanitizerMask::bitPosToMask(SO_##ID);    \
  static_assert(SanitizerMask::checkBitPos(SO_##ID), "Bit position too big.");
#define SANITIZER_GROUP(NAME, ID, ALIAS)                                       \
  static constexpr SanitizerMask ID = SanitizerMask(ALIAS);                    \
  static constexpr SanitizerMask ID##Group =                                   \
      SanitizerMask::bitPosToMask(SO_##ID##Group);                             \
  static_assert(SanitizerMask::checkBitPos(SO_##ID##Group),                    \
                "Bit position too big.");
#include "clang/Basic/Sanitizers.def"
}; // SanitizerKind

struct SanitizerSet {
  /// Check if a certain (single) sanitizer is enabled.
  bool has(SanitizerMask K) const {
    assert(K.isPowerOf2() && "Has to be a single sanitizer.");
    return static_cast<bool>(Mask & K);
  }

/// Check if one or more sanitizers are enabled.
  bool hasOneOf(SanitizerMask K) const { return static_cast<bool>(Mask & K); }

/// Enable or disable a certain (single) sanitizer.
  void set(SanitizerMask K, bool Value) {
    assert(K.isPowerOf2() && "Has to be a single sanitizer.");
    Mask = Value ? (Mask | K) : (Mask & ~K);
  }

/// Disable the sanitizers specified in \p K.
  void clear(SanitizerMask K = SanitizerKind::All) { Mask &= ~K; }

/// Returns true if no sanitizers are enabled.
  bool empty() const { return !Mask; }

/// Bitmask of enabled sanitizers.
  SanitizerMask Mask;
};

/// Parse a single value from a -fsanitize= or -fno-sanitize= value list.
/// Returns a non-zero SanitizerMask, or \c 0 if \p Value is not known.
SanitizerMask parseSanitizerValue(StringRef Value, bool AllowGroups);

/// For each sanitizer group bit set in \p Kinds, set the bits for sanitizers
/// this group enables.
SanitizerMask expandSanitizerGroups(SanitizerMask Kinds);

/// Return the sanitizers which do not affect preprocessing.
inline SanitizerMask getPPTransparentSanitizers() {
  return SanitizerKind::CFI | SanitizerKind::Integer |
         SanitizerKind::ImplicitConversion | SanitizerKind::Nullability |
         SanitizerKind::Undefined | SanitizerKind::FloatDivideByZero;
}

} // namespace clang

#endif // LLVM_CLANG_BASIC_SANITIZERS_H

003 File Manager

Editing: Sanitizers.h

Upload File

Create Folder