File Manager

003 File Manager

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

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

📁 ..
📄 APValue.h(20.92 KB)
📄 AST.h(907 B)
📄 ASTConcept.h(7.02 KB)
📄 ASTConsumer.h(5.99 KB)
📄 ASTContext.h(122.68 KB)
📄 ASTContextAllocate.h(1.33 KB)
📄 ASTDiagnostic.h(1.34 KB)
📄 ASTDumper.h(1.59 KB)
📄 ASTDumperUtils.h(3.49 KB)
📄 ASTFwd.h(1.01 KB)
📄 ASTImporter.h(22.86 KB)
📄 ASTImporterLookupTable.h(2.7 KB)
📄 ASTImporterSharedState.h(2.51 KB)
📄 ASTLambda.h(3.04 KB)
📄 ASTMutationListener.h(5.84 KB)
📄 ASTNodeTraverser.h(21.38 KB)
📄 ASTStructuralEquivalence.h(5.08 KB)
📄 ASTTypeTraits.h(19.65 KB)
📄 ASTUnresolvedSet.h(3.37 KB)
📄 ASTVector.h(11.75 KB)
📄 AbstractBasicReader.h(8.82 KB)
📄 AbstractBasicWriter.h(7.97 KB)
📄 AbstractTypeReader.h(922 B)
📄 AbstractTypeWriter.h(944 B)
📄 Attr.h(11.87 KB)
📄 AttrIterator.h(4.14 KB)
📄 AttrVisitor.h(2.56 KB)
📄 Availability.h(1.97 KB)
📄 BaseSubobject.h(2.74 KB)
📄 BuiltinTypes.def(9.91 KB)
📄 CXXInheritance.h(14.87 KB)
📄 CXXRecordDeclDefinitionBits.def(9.23 KB)
📄 CanonicalType.h(24.86 KB)
📄 CharUnits.h(8.02 KB)
📄 Comment.h(31.03 KB)
📄 CommentBriefParser.h(1.39 KB)
📄 CommentCommandTraits.h(5.86 KB)
📄 CommentCommands.td(9.27 KB)
📄 CommentDiagnostic.h(509 B)
📄 CommentHTMLNamedCharacterReferences.td(4.98 KB)
📄 CommentHTMLTags.td(2.17 KB)
📄 CommentLexer.h(9.96 KB)
📄 CommentParser.h(3.24 KB)
📄 CommentSema.h(9.87 KB)
📄 CommentVisitor.h(2.38 KB)
📄 ComparisonCategories.h(7.41 KB)
📄 ComputeDependence.h(7.41 KB)
📄 CurrentSourceLocExprScope.h(2.43 KB)
📄 DataCollection.h(2.45 KB)
📄 Decl.h(168.07 KB)
📄 DeclAccessPair.h(1.77 KB)
📄 DeclBase.h(93.13 KB)
📄 DeclCXX.h(151.69 KB)
📄 DeclContextInternals.h(8.22 KB)
📄 DeclFriend.h(8.06 KB)
📄 DeclGroup.h(4.11 KB)
📄 DeclLookups.h(3.64 KB)
📄 DeclObjC.h(101.2 KB)
📄 DeclObjCCommon.h(1.72 KB)
📄 DeclOpenMP.h(19.33 KB)
📄 DeclTemplate.h(122.19 KB)
📄 DeclVisitor.h(2.51 KB)
📄 DeclarationName.h(33.77 KB)
📄 DependenceFlags.h(10.99 KB)
📄 DependentDiagnostic.h(5.4 KB)
📄 EvaluatedExprVisitor.h(4.45 KB)
📄 Expr.h(234.85 KB)
📄 ExprCXX.h(169.78 KB)
📄 ExprConcepts.h(19.62 KB)
📄 ExprObjC.h(58.96 KB)
📄 ExprOpenMP.h(15.48 KB)
📄 ExternalASTMerger.h(8.11 KB)
📄 ExternalASTSource.h(20.55 KB)
📄 FormatString.h(22.81 KB)
📄 GlobalDecl.h(7.16 KB)
📄 JSONNodeDumper.h(17.53 KB)
📄 LambdaCapture.h(4.71 KB)
📄 LexicallyOrderedRecursiveASTVisitor.h(5.92 KB)
📄 LocInfoType.h(1.84 KB)
📄 Mangle.h(10.65 KB)
📄 MangleNumberingContext.h(2 KB)
📄 NSAPI.h(9.23 KB)
📄 NestedNameSpecifier.h(18.53 KB)
📄 NonTrivialTypeVisitor.h(4 KB)
📄 ODRHash.h(3.42 KB)
📄 OSLog.h(5.08 KB)
📄 OpenMPClause.h(276.08 KB)
📄 OperationKinds.def(14.91 KB)
📄 OperationKinds.h(1.5 KB)
📄 OptionalDiagnostic.h(2.39 KB)
📄 ParentMap.h(1.89 KB)
📄 ParentMapContext.h(4.74 KB)
📄 PrettyDeclStackTrace.h(1.39 KB)
📄 PrettyPrinter.h(8.47 KB)
📄 PropertiesBase.td(17.03 KB)
📄 QualTypeNames.h(3.15 KB)
📄 RawCommentList.h(6.6 KB)
📄 RecordLayout.h(11.49 KB)
📄 RecursiveASTVisitor.h(124.41 KB)
📄 Redeclarable.h(14.34 KB)
📄 SelectorLocationsKind.h(3.28 KB)
📄 Stmt.h(113 KB)
📄 StmtCXX.h(17.59 KB)
📄 StmtDataCollectors.td(5.64 KB)
📄 StmtGraphTraits.h(2.18 KB)
📄 StmtIterator.h(4.2 KB)
📄 StmtObjC.h(12.86 KB)
📄 StmtOpenMP.h(189.5 KB)
📄 StmtVisitor.h(8.74 KB)
📄 TemplateArgumentVisitor.h(3.38 KB)
📄 TemplateBase.h(22.86 KB)
📄 TemplateName.h(19.34 KB)
📄 TextNodeDumper.h(15.7 KB)
📄 Type.h(248.38 KB)
📄 TypeLoc.h(73.03 KB)
📄 TypeLocNodes.def(1.45 KB)
📄 TypeLocVisitor.h(1.76 KB)
📄 TypeOrdering.h(2.38 KB)
📄 TypeProperties.td(25.87 KB)
📄 TypeVisitor.h(3.32 KB)
📄 UnresolvedSet.h(5.25 KB)
📄 VTTBuilder.h(5.19 KB)
📄 VTableBuilder.h(20.31 KB)

Editing: CharUnits.h

//===--- CharUnits.h - Character units for sizes and offsets ----*- 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
//
//===----------------------------------------------------------------------===//
//
//  This file defines the CharUnits class
//
//===----------------------------------------------------------------------===//

#ifndef LLVM_CLANG_AST_CHARUNITS_H
#define LLVM_CLANG_AST_CHARUNITS_H

#include "llvm/ADT/DenseMapInfo.h"
#include "llvm/Support/Alignment.h"
#include "llvm/Support/DataTypes.h"
#include "llvm/Support/MathExtras.h"

namespace clang {

/// CharUnits - This is an opaque type for sizes expressed in character units.
  /// Instances of this type represent a quantity as a multiple of the size
  /// of the standard C type, char, on the target architecture. As an opaque
  /// type, CharUnits protects you from accidentally combining operations on
  /// quantities in bit units and character units.
  ///
  /// In both C and C++, an object of type 'char', 'signed char', or 'unsigned
  /// char' occupies exactly one byte, so 'character unit' and 'byte' refer to
  /// the same quantity of storage. However, we use the term 'character unit'
  /// rather than 'byte' to avoid an implication that a character unit is
  /// exactly 8 bits.
  ///
  /// For portability, never assume that a target character is 8 bits wide. Use
  /// CharUnit values wherever you calculate sizes, offsets, or alignments
  /// in character units.
  class CharUnits {
    public:
      typedef int64_t QuantityType;

private:
      QuantityType Quantity = 0;

explicit CharUnits(QuantityType C) : Quantity(C) {}

public:

/// CharUnits - A default constructor.
      CharUnits() = default;

/// Zero - Construct a CharUnits quantity of zero.
      static CharUnits Zero() {
        return CharUnits(0);
      }

/// One - Construct a CharUnits quantity of one.
      static CharUnits One() {
        return CharUnits(1);
      }

/// fromQuantity - Construct a CharUnits quantity from a raw integer type.
      static CharUnits fromQuantity(QuantityType Quantity) {
        return CharUnits(Quantity);
      }

// Compound assignment.
      CharUnits& operator+= (const CharUnits &Other) {
        Quantity += Other.Quantity;
        return *this;
      }
      CharUnits& operator++ () {
        ++Quantity;
        return *this;
      }
      CharUnits operator++ (int) {
        return CharUnits(Quantity++);
      }
      CharUnits& operator-= (const CharUnits &Other) {
        Quantity -= Other.Quantity;
        return *this;
      }
      CharUnits& operator-- () {
        --Quantity;
        return *this;
      }
      CharUnits operator-- (int) {
        return CharUnits(Quantity--);
      }

// Comparison operators.
      bool operator== (const CharUnits &Other) const {
        return Quantity == Other.Quantity;
      }
      bool operator!= (const CharUnits &Other) const {
        return Quantity != Other.Quantity;
      }

// Relational operators.
      bool operator<  (const CharUnits &Other) const {
        return Quantity <  Other.Quantity;
      }
      bool operator<= (const CharUnits &Other) const {
        return Quantity <= Other.Quantity;
      }
      bool operator>  (const CharUnits &Other) const {
        return Quantity >  Other.Quantity;
      }
      bool operator>= (const CharUnits &Other) const {
        return Quantity >= Other.Quantity;
      }

// Other predicates.

/// isZero - Test whether the quantity equals zero.
      bool isZero() const     { return Quantity == 0; }

/// isOne - Test whether the quantity equals one.
      bool isOne() const      { return Quantity == 1; }

/// isPositive - Test whether the quantity is greater than zero.
      bool isPositive() const { return Quantity  > 0; }

/// isNegative - Test whether the quantity is less than zero.
      bool isNegative() const { return Quantity  < 0; }

/// isPowerOfTwo - Test whether the quantity is a power of two.
      /// Zero is not a power of two.
      bool isPowerOfTwo() const {
        return (Quantity & -Quantity) == Quantity;
      }

/// Test whether this is a multiple of the other value.
      ///
      /// Among other things, this promises that
      /// self.alignTo(N) will just return self.
      bool isMultipleOf(CharUnits N) const {
        return (*this % N) == 0;
      }

// Arithmetic operators.
      CharUnits operator* (QuantityType N) const {
        return CharUnits(Quantity * N);
      }
      CharUnits &operator*= (QuantityType N) {
        Quantity *= N;
        return *this;
      }
      CharUnits operator/ (QuantityType N) const {
        return CharUnits(Quantity / N);
      }
      CharUnits &operator/= (QuantityType N) {
        Quantity /= N;
        return *this;
      }
      QuantityType operator/ (const CharUnits &Other) const {
        return Quantity / Other.Quantity;
      }
      CharUnits operator% (QuantityType N) const {
        return CharUnits(Quantity % N);
      }
      QuantityType operator% (const CharUnits &Other) const {
        return Quantity % Other.Quantity;
      }
      CharUnits operator+ (const CharUnits &Other) const {
        return CharUnits(Quantity + Other.Quantity);
      }
      CharUnits operator- (const CharUnits &Other) const {
        return CharUnits(Quantity - Other.Quantity);
      }
      CharUnits operator- () const {
        return CharUnits(-Quantity);
      }

// Conversions.

/// getQuantity - Get the raw integer representation of this quantity.
      QuantityType getQuantity() const { return Quantity; }

/// getAsAlign - Returns Quantity as a valid llvm::Align,
      /// Beware llvm::Align assumes power of two 8-bit bytes.
      llvm::Align getAsAlign() const { return llvm::Align(Quantity); }

/// alignTo - Returns the next integer (mod 2**64) that is
      /// greater than or equal to this quantity and is a multiple of \p Align.
      /// Align must be non-zero.
      CharUnits alignTo(const CharUnits &Align) const {
        return CharUnits(llvm::alignTo(Quantity, Align.Quantity));
      }

/// Given that this is a non-zero alignment value, what is the
      /// alignment at the given offset?
      CharUnits alignmentAtOffset(CharUnits offset) const {
        assert(Quantity != 0 && "offsetting from unknown alignment?");
        return CharUnits(llvm::MinAlign(Quantity, offset.Quantity));
      }

/// Given that this is the alignment of the first element of an
      /// array, return the minimum alignment of any element in the array.
      CharUnits alignmentOfArrayElement(CharUnits elementSize) const {
        // Since we don't track offsetted alignments, the alignment of
        // the second element (or any odd element) will be minimally
        // aligned.
        return alignmentAtOffset(elementSize);
      }

}; // class CharUnit
} // namespace clang

inline clang::CharUnits operator* (clang::CharUnits::QuantityType Scale,
                                   const clang::CharUnits &CU) {
  return CU * Scale;
}

namespace llvm {

template<> struct DenseMapInfo<clang::CharUnits> {
  static clang::CharUnits getEmptyKey() {
    clang::CharUnits::QuantityType Quantity =
      DenseMapInfo<clang::CharUnits::QuantityType>::getEmptyKey();

return clang::CharUnits::fromQuantity(Quantity);
  }

static clang::CharUnits getTombstoneKey() {
    clang::CharUnits::QuantityType Quantity =
      DenseMapInfo<clang::CharUnits::QuantityType>::getTombstoneKey();

return clang::CharUnits::fromQuantity(Quantity);
  }

static unsigned getHashValue(const clang::CharUnits &CU) {
    clang::CharUnits::QuantityType Quantity = CU.getQuantity();
    return DenseMapInfo<clang::CharUnits::QuantityType>::getHashValue(Quantity);
  }

static bool isEqual(const clang::CharUnits &LHS,
                      const clang::CharUnits &RHS) {
    return LHS == RHS;
  }
};

} // end namespace llvm

#endif // LLVM_CLANG_AST_CHARUNITS_H

003 File Manager

Editing: CharUnits.h

Upload File

Create Folder