/usr/src/gnu/usr.bin/clang/libclangAST/../../../llvm/llvm/include/llvm/Support/Alignment.h

Bug Summary

File:	src/gnu/usr.bin/clang/libclangAST/../../../llvm/llvm/include/llvm/Support/Alignment.h
Warning:	line 85, column 47 The result of the left shift is undefined due to shifting by '255', which is greater or equal to the width of type 'uint64_t'

Annotated Source Code

Press '?' to see keyboard shortcuts

Show analyzer invocation

clang -cc1 -cc1 -triple amd64-unknown-openbsd7.0 -analyze -disable-free -disable-llvm-verifier -discard-value-names -main-file-name CommentSema.cpp -analyzer-store=region -analyzer-opt-analyze-nested-blocks -analyzer-checker=core -analyzer-checker=apiModeling -analyzer-checker=unix -analyzer-checker=deadcode -analyzer-checker=cplusplus -analyzer-checker=security.insecureAPI.UncheckedReturn -analyzer-checker=security.insecureAPI.getpw -analyzer-checker=security.insecureAPI.gets -analyzer-checker=security.insecureAPI.mktemp -analyzer-checker=security.insecureAPI.mkstemp -analyzer-checker=security.insecureAPI.vfork -analyzer-checker=nullability.NullPassedToNonnull -analyzer-checker=nullability.NullReturnedFromNonnull -analyzer-output plist -w -setup-static-analyzer -mrelocation-model static -mframe-pointer=all -relaxed-aliasing -fno-rounding-math -mconstructor-aliases -munwind-tables -target-cpu x86-64 -tune-cpu generic -debugger-tuning=gdb -fcoverage-compilation-dir=/usr/src/gnu/usr.bin/clang/libclangAST/obj -resource-dir /usr/local/lib/clang/13.0.0 -I /usr/src/gnu/usr.bin/clang/libclangAST/obj/../include/clang/AST -I /usr/src/gnu/usr.bin/clang/libclangAST/../../../llvm/clang/include -I /usr/src/gnu/usr.bin/clang/libclangAST/../../../llvm/llvm/include -I /usr/src/gnu/usr.bin/clang/libclangAST/../include -I /usr/src/gnu/usr.bin/clang/libclangAST/obj -I /usr/src/gnu/usr.bin/clang/libclangAST/obj/../include -D NDEBUG -D __STDC_LIMIT_MACROS -D __STDC_CONSTANT_MACROS -D __STDC_FORMAT_MACROS -D LLVM_PREFIX="/usr" -internal-isystem /usr/include/c++/v1 -internal-isystem /usr/local/lib/clang/13.0.0/include -internal-externc-isystem /usr/include -O2 -Wno-unused-parameter -Wwrite-strings -Wno-missing-field-initializers -Wno-long-long -Wno-comment -std=c++14 -fdeprecated-macro -fdebug-compilation-dir=/usr/src/gnu/usr.bin/clang/libclangAST/obj -ferror-limit 19 -fvisibility-inlines-hidden -fwrapv -stack-protector 2 -fno-rtti -fgnuc-version=4.2.1 -vectorize-loops -vectorize-slp -fno-builtin-malloc -fno-builtin-calloc -fno-builtin-realloc -fno-builtin-valloc -fno-builtin-free -fno-builtin-strdup -fno-builtin-strndup -analyzer-output=html -faddrsig -D__GCC_HAVE_DWARF2_CFI_ASM=1 -o /home/ben/Projects/vmm/scan-build/2022-01-12-194120-40624-1 -x c++ /usr/src/gnu/usr.bin/clang/libclangAST/../../../llvm/clang/lib/AST/CommentSema.cpp

/usr/src/gnu/usr.bin/clang/libclangAST/../../../llvm/clang/lib/AST/CommentSema.cpp

→

1//===--- CommentSema.cpp - Doxygen comment semantic analysis --------------===//
2//
3// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
4// See https://llvm.org/LICENSE.txt for license information.
5// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
6//
7//===----------------------------------------------------------------------===//

9#include "clang/AST/CommentSema.h"
10#include "clang/AST/Attr.h"
11#include "clang/AST/CommentCommandTraits.h"
12#include "clang/AST/CommentDiagnostic.h"
13#include "clang/AST/Decl.h"
14#include "clang/AST/DeclTemplate.h"
15#include "clang/Basic/LLVM.h"
16#include "clang/Basic/SourceManager.h"
17#include "clang/Lex/Preprocessor.h"
18#include "llvm/ADT/SmallString.h"
19#include "llvm/ADT/StringSwitch.h"

21namespace clang {
22namespace comments {

24namespace {
25#include "clang/AST/CommentHTMLTagsProperties.inc"
26} // end anonymous namespace

28Sema::Sema(llvm::BumpPtrAllocator &Allocator, const SourceManager &SourceMgr,
         DiagnosticsEngine &Diags, CommandTraits &Traits,
         const Preprocessor *PP) :
  Allocator(Allocator), SourceMgr(SourceMgr), Diags(Diags), Traits(Traits),
  PP(PP), ThisDeclInfo(nullptr), BriefCommand(nullptr),
  HeaderfileCommand(nullptr) {
34}

36void Sema::setDecl(const Decl *D) {
if (!D)
  return;

ThisDeclInfo = new (Allocator) DeclInfo;
ThisDeclInfo->CommentDecl = D;
ThisDeclInfo->IsFilled = false;
43}

45ParagraphComment *Sema::actOnParagraphComment(
                            ArrayRef<InlineContentComment *> Content) {
return new (Allocator) ParagraphComment(Content);
48}

50BlockCommandComment *Sema::actOnBlockCommandStart(
                                    SourceLocation LocBegin,
                                    SourceLocation LocEnd,
                                    unsigned CommandID,
                                    CommandMarkerKind CommandMarker) {
BlockCommandComment *BC = new (Allocator) BlockCommandComment(LocBegin, LocEnd,
                                                              CommandID,
                                                              CommandMarker);
checkContainerDecl(BC);
return BC;
60}

62void Sema::actOnBlockCommandArgs(BlockCommandComment *Command,
                               ArrayRef<BlockCommandComment::Argument> Args) {
Command->setArgs(Args);
65}

67void Sema::actOnBlockCommandFinish(BlockCommandComment *Command,
                                 ParagraphComment *Paragraph) {
Command->setParagraph(Paragraph);
checkBlockCommandEmptyParagraph(Command);
checkBlockCommandDuplicate(Command);
if (ThisDeclInfo) {
  // These checks only make sense if the comment is attached to a
  // declaration.
  checkReturnsCommand(Command);
  checkDeprecatedCommand(Command);
}
78}

80ParamCommandComment *Sema::actOnParamCommandStart(
                                    SourceLocation LocBegin,
                                    SourceLocation LocEnd,
                                    unsigned CommandID,
                                    CommandMarkerKind CommandMarker) {
ParamCommandComment *Command =
    new (Allocator) ParamCommandComment(LocBegin, LocEnd, CommandID,
                                        CommandMarker);

if (!isFunctionDecl() && !isFunctionOrBlockPointerVarLikeDecl())
  Diag(Command->getLocation(),
       diag::warn_doc_param_not_attached_to_a_function_decl)
    << CommandMarker
    << Command->getCommandNameRange(Traits);

return Command;
96}

98void Sema::checkFunctionDeclVerbatimLine(const BlockCommandComment *Comment) {
const CommandInfo *Info = Traits.getCommandInfo(Comment->getCommandID());
if (!Info->IsFunctionDeclarationCommand)
  return;

unsigned DiagSelect;
switch (Comment->getCommandID()) {
  case CommandTraits::KCI_function:
    DiagSelect = (!isAnyFunctionDecl() && !isFunctionTemplateDecl())? 1 : 0;
    break;
  case CommandTraits::KCI_functiongroup:
    DiagSelect = (!isAnyFunctionDecl() && !isFunctionTemplateDecl())? 2 : 0;
    break;
  case CommandTraits::KCI_method:
    DiagSelect = !isObjCMethodDecl() ? 3 : 0;
    break;
  case CommandTraits::KCI_methodgroup:
    DiagSelect = !isObjCMethodDecl() ? 4 : 0;
    break;
  case CommandTraits::KCI_callback:
    DiagSelect = !isFunctionPointerVarDecl() ? 5 : 0;
    break;
  default:
    DiagSelect = 0;
    break;
}
if (DiagSelect)
  Diag(Comment->getLocation(), diag::warn_doc_function_method_decl_mismatch)
  << Comment->getCommandMarker()
  << (DiagSelect-1) << (DiagSelect-1)
  << Comment->getSourceRange();
129}

131void Sema::checkContainerDeclVerbatimLine(const BlockCommandComment *Comment) {
const CommandInfo *Info = Traits.getCommandInfo(Comment->getCommandID());
if (!Info->IsRecordLikeDeclarationCommand)
  return;
unsigned DiagSelect;
switch (Comment->getCommandID()) {
  case CommandTraits::KCI_class:
    DiagSelect =
        (!isClassOrStructOrTagTypedefDecl() && !isClassTemplateDecl()) ? 1
                                                                       : 0;
    // Allow @class command on @interface declarations.
    // FIXME. Currently, \class and @class are indistinguishable. So,
    // \class is also allowed on an @interface declaration
    if (DiagSelect && Comment->getCommandMarker() && isObjCInterfaceDecl())
      DiagSelect = 0;
    break;
  case CommandTraits::KCI_interface:
    DiagSelect = !isObjCInterfaceDecl() ? 2 : 0;
    break;
  case CommandTraits::KCI_protocol:
    DiagSelect = !isObjCProtocolDecl() ? 3 : 0;
    break;
  case CommandTraits::KCI_struct:
    DiagSelect = !isClassOrStructOrTagTypedefDecl() ? 4 : 0;
    break;
  case CommandTraits::KCI_union:
    DiagSelect = !isUnionDecl() ? 5 : 0;
    break;
  default:
    DiagSelect = 0;
    break;
}
if (DiagSelect)
  Diag(Comment->getLocation(), diag::warn_doc_api_container_decl_mismatch)
  << Comment->getCommandMarker()
  << (DiagSelect-1) << (DiagSelect-1)
  << Comment->getSourceRange();
168}

170void Sema::checkContainerDecl(const BlockCommandComment *Comment) {
const CommandInfo *Info = Traits.getCommandInfo(Comment->getCommandID());
if (!Info->IsRecordLikeDetailCommand || isRecordLikeDecl())
  return;
unsigned DiagSelect;
switch (Comment->getCommandID()) {
  case CommandTraits::KCI_classdesign:
    DiagSelect = 1;
    break;
  case CommandTraits::KCI_coclass:
    DiagSelect = 2;
    break;
  case CommandTraits::KCI_dependency:
    DiagSelect = 3;
    break;
  case CommandTraits::KCI_helper:
    DiagSelect = 4;
    break;
  case CommandTraits::KCI_helperclass:
    DiagSelect = 5;
    break;
  case CommandTraits::KCI_helps:
    DiagSelect = 6;
    break;
  case CommandTraits::KCI_instancesize:
    DiagSelect = 7;
    break;
  case CommandTraits::KCI_ownership:
    DiagSelect = 8;
    break;
  case CommandTraits::KCI_performance:
    DiagSelect = 9;
    break;
  case CommandTraits::KCI_security:
    DiagSelect = 10;
    break;
  case CommandTraits::KCI_superclass:
    DiagSelect = 11;
    break;
  default:
    DiagSelect = 0;
    break;
}
if (DiagSelect)
  Diag(Comment->getLocation(), diag::warn_doc_container_decl_mismatch)
  << Comment->getCommandMarker()
  << (DiagSelect-1)
  << Comment->getSourceRange();
218}

220/// Turn a string into the corresponding PassDirection or -1 if it's not
221/// valid.
222static int getParamPassDirection(StringRef Arg) {
return llvm::StringSwitch<int>(Arg)
    .Case("[in]", ParamCommandComment::In)
    .Case("[out]", ParamCommandComment::Out)
    .Cases("[in,out]", "[out,in]", ParamCommandComment::InOut)
    .Default(-1);
228}

230void Sema::actOnParamCommandDirectionArg(ParamCommandComment *Command,
                                       SourceLocation ArgLocBegin,
                                       SourceLocation ArgLocEnd,
                                       StringRef Arg) {
std::string ArgLower = Arg.lower();
int Direction = getParamPassDirection(ArgLower);

if (Direction == -1) {
  // Try again with whitespace removed.
  ArgLower.erase(
      std::remove_if(ArgLower.begin(), ArgLower.end(), clang::isWhitespace),
      ArgLower.end());
  Direction = getParamPassDirection(ArgLower);

  SourceRange ArgRange(ArgLocBegin, ArgLocEnd);
  if (Direction != -1) {
    const char *FixedName = ParamCommandComment::getDirectionAsString(
        (ParamCommandComment::PassDirection)Direction);
    Diag(ArgLocBegin, diag::warn_doc_param_spaces_in_direction)
        << ArgRange << FixItHint::CreateReplacement(ArgRange, FixedName);
  } else {
    Diag(ArgLocBegin, diag::warn_doc_param_invalid_direction) << ArgRange;
    Direction = ParamCommandComment::In; // Sane fall back.
  }
}
Command->setDirection((ParamCommandComment::PassDirection)Direction,
                      /*Explicit=*/true);
257}

259void Sema::actOnParamCommandParamNameArg(ParamCommandComment *Command,
                                       SourceLocation ArgLocBegin,
                                       SourceLocation ArgLocEnd,
                                       StringRef Arg) {
// Parser will not feed us more arguments than needed.
assert(Command->getNumArgs() == 0)((void)0);

if (!Command->isDirectionExplicit()) {
  // User didn't provide a direction argument.
  Command->setDirection(ParamCommandComment::In, /* Explicit = */ false);
}
typedef BlockCommandComment::Argument Argument;
Argument *A = new (Allocator) Argument(SourceRange(ArgLocBegin,
                                                   ArgLocEnd),
                                       Arg);
Command->setArgs(llvm::makeArrayRef(A, 1));
275}

277void Sema::actOnParamCommandFinish(ParamCommandComment *Command,
                                 ParagraphComment *Paragraph) {
Command->setParagraph(Paragraph);
checkBlockCommandEmptyParagraph(Command);
281}

283TParamCommandComment *Sema::actOnTParamCommandStart(
                                    SourceLocation LocBegin,
                                    SourceLocation LocEnd,
                                    unsigned CommandID,
                                    CommandMarkerKind CommandMarker) {
TParamCommandComment *Command =
    new (Allocator) TParamCommandComment(LocBegin, LocEnd, CommandID,
                                         CommandMarker);

if (!isTemplateOrSpecialization())
  Diag(Command->getLocation(),
       diag::warn_doc_tparam_not_attached_to_a_template_decl)
    << CommandMarker
    << Command->getCommandNameRange(Traits);

return Command;
299}

301void Sema::actOnTParamCommandParamNameArg(TParamCommandComment *Command,
                                        SourceLocation ArgLocBegin,
                                        SourceLocation ArgLocEnd,
                                        StringRef Arg) {
// Parser will not feed us more arguments than needed.
assert(Command->getNumArgs() == 0)((void)0);

typedef BlockCommandComment::Argument Argument;
Argument *A = new (Allocator) Argument(SourceRange(ArgLocBegin,
                                                   ArgLocEnd),
                                       Arg);
Command->setArgs(llvm::makeArrayRef(A, 1));

if (!isTemplateOrSpecialization()) {
  // We already warned that this \\tparam is not attached to a template decl.
  return;
}

const TemplateParameterList *TemplateParameters =
    ThisDeclInfo->TemplateParameters;
SmallVector<unsigned, 2> Position;
if (resolveTParamReference(Arg, TemplateParameters, &Position)) {
  Command->setPosition(copyArray(llvm::makeArrayRef(Position)));
  TParamCommandComment *&PrevCommand = TemplateParameterDocs[Arg];
  if (PrevCommand) {
    SourceRange ArgRange(ArgLocBegin, ArgLocEnd);
    Diag(ArgLocBegin, diag::warn_doc_tparam_duplicate)
      << Arg << ArgRange;
    Diag(PrevCommand->getLocation(), diag::note_doc_tparam_previous)
      << PrevCommand->getParamNameRange();
  }
  PrevCommand = Command;
  return;
}

SourceRange ArgRange(ArgLocBegin, ArgLocEnd);
Diag(ArgLocBegin, diag::warn_doc_tparam_not_found)
  << Arg << ArgRange;

if (!TemplateParameters || TemplateParameters->size() == 0)
  return;

StringRef CorrectedName;
if (TemplateParameters->size() == 1) {
  const NamedDecl *Param = TemplateParameters->getParam(0);
  const IdentifierInfo *II = Param->getIdentifier();
  if (II)
    CorrectedName = II->getName();
} else {
  CorrectedName = correctTypoInTParamReference(Arg, TemplateParameters);
}

if (!CorrectedName.empty()) {
  Diag(ArgLocBegin, diag::note_doc_tparam_name_suggestion)
    << CorrectedName
    << FixItHint::CreateReplacement(ArgRange, CorrectedName);
}
358}

360void Sema::actOnTParamCommandFinish(TParamCommandComment *Command,
                                  ParagraphComment *Paragraph) {
Command->setParagraph(Paragraph);
checkBlockCommandEmptyParagraph(Command);
364}

366InlineCommandComment *Sema::actOnInlineCommand(SourceLocation CommandLocBegin,
                                             SourceLocation CommandLocEnd,
                                             unsigned CommandID) {
ArrayRef<InlineCommandComment::Argument> Args;
StringRef CommandName = Traits.getCommandInfo(CommandID)->Name;
return new (Allocator) InlineCommandComment(
                                CommandLocBegin,
                                CommandLocEnd,
                                CommandID,
                                getInlineCommandRenderKind(CommandName),
                                Args);
377}

379InlineCommandComment *Sema::actOnInlineCommand(SourceLocation CommandLocBegin,
                                             SourceLocation CommandLocEnd,
                                             unsigned CommandID,
                                             SourceLocation ArgLocBegin,
                                             SourceLocation ArgLocEnd,
                                             StringRef Arg) {
typedef InlineCommandComment::Argument Argument;
Argument *A = new (Allocator) Argument(SourceRange(ArgLocBegin,
                                                   ArgLocEnd),
                                       Arg);
StringRef CommandName = Traits.getCommandInfo(CommandID)->Name;

return new (Allocator) InlineCommandComment(
                                CommandLocBegin,
                                CommandLocEnd,
                                CommandID,
                                getInlineCommandRenderKind(CommandName),
                                llvm::makeArrayRef(A, 1));
397}

399InlineContentComment *Sema::actOnUnknownCommand(SourceLocation LocBegin,
                                              SourceLocation LocEnd,
                                              StringRef CommandName) {
unsigned CommandID = Traits.registerUnknownCommand(CommandName)->getID();
return actOnUnknownCommand(LocBegin, LocEnd, CommandID);
404}

406InlineContentComment *Sema::actOnUnknownCommand(SourceLocation LocBegin,
                                              SourceLocation LocEnd,
                                              unsigned CommandID) {
ArrayRef<InlineCommandComment::Argument> Args;
return new (Allocator) InlineCommandComment(
                                LocBegin, LocEnd, CommandID,
                                InlineCommandComment::RenderNormal,
                                Args);
414}

416TextComment *Sema::actOnText(SourceLocation LocBegin,
                           SourceLocation LocEnd,
                           StringRef Text) {
return new (Allocator) TextComment(LocBegin, LocEnd, Text);
420}

422VerbatimBlockComment *Sema::actOnVerbatimBlockStart(SourceLocation Loc,
                                                  unsigned CommandID) {
StringRef CommandName = Traits.getCommandInfo(CommandID)->Name;
return new (Allocator) VerbatimBlockComment(
                                Loc,
                                Loc.getLocWithOffset(1 + CommandName.size()),
                                CommandID);
429}

431VerbatimBlockLineComment *Sema::actOnVerbatimBlockLine(SourceLocation Loc,
                                                     StringRef Text) {
return new (Allocator) VerbatimBlockLineComment(Loc, Text);
434}

436void Sema::actOnVerbatimBlockFinish(
                          VerbatimBlockComment *Block,
                          SourceLocation CloseNameLocBegin,
                          StringRef CloseName,
                          ArrayRef<VerbatimBlockLineComment *> Lines) {
Block->setCloseName(CloseName, CloseNameLocBegin);
Block->setLines(Lines);
443}

445VerbatimLineComment *Sema::actOnVerbatimLine(SourceLocation LocBegin,
                                           unsigned CommandID,
                                           SourceLocation TextBegin,
                                           StringRef Text) {
VerbatimLineComment *VL = new (Allocator) VerbatimLineComment(
                            LocBegin,
                            TextBegin.getLocWithOffset(Text.size()),
                            CommandID,
                            TextBegin,
                            Text);
checkFunctionDeclVerbatimLine(VL);
checkContainerDeclVerbatimLine(VL);
return VL;
458}

460HTMLStartTagComment *Sema::actOnHTMLStartTagStart(SourceLocation LocBegin,
                                                StringRef TagName) {
return new (Allocator) HTMLStartTagComment(LocBegin, TagName);
463}

465void Sema::actOnHTMLStartTagFinish(
                            HTMLStartTagComment *Tag,
                            ArrayRef<HTMLStartTagComment::Attribute> Attrs,
                            SourceLocation GreaterLoc,
                            bool IsSelfClosing) {
Tag->setAttrs(Attrs);
Tag->setGreaterLoc(GreaterLoc);
if (IsSelfClosing)
  Tag->setSelfClosing();
else if (!isHTMLEndTagForbidden(Tag->getTagName()))
  HTMLOpenTags.push_back(Tag);
476}

478HTMLEndTagComment *Sema::actOnHTMLEndTag(SourceLocation LocBegin,
                                       SourceLocation LocEnd,
                                       StringRef TagName) {
HTMLEndTagComment *HET =
    new (Allocator) HTMLEndTagComment(LocBegin, LocEnd, TagName);
if (isHTMLEndTagForbidden(TagName)) {
  Diag(HET->getLocation(), diag::warn_doc_html_end_forbidden)
    << TagName << HET->getSourceRange();
  HET->setIsMalformed();
  return HET;
}

bool FoundOpen = false;
for (SmallVectorImpl<HTMLStartTagComment *>::const_reverse_iterator
     I = HTMLOpenTags.rbegin(), E = HTMLOpenTags.rend();
     I != E; ++I) {
  if ((*I)->getTagName() == TagName) {
    FoundOpen = true;
    break;
  }
}
if (!FoundOpen) {
  Diag(HET->getLocation(), diag::warn_doc_html_end_unbalanced)
    << HET->getSourceRange();
  HET->setIsMalformed();
  return HET;
}

while (!HTMLOpenTags.empty()) {
  HTMLStartTagComment *HST = HTMLOpenTags.pop_back_val();
  StringRef LastNotClosedTagName = HST->getTagName();
  if (LastNotClosedTagName == TagName) {
    // If the start tag is malformed, end tag is malformed as well.
    if (HST->isMalformed())
      HET->setIsMalformed();
    break;
  }

  if (isHTMLEndTagOptional(LastNotClosedTagName))
    continue;

  bool OpenLineInvalid;
  const unsigned OpenLine = SourceMgr.getPresumedLineNumber(
                                              HST->getLocation(),
                                              &OpenLineInvalid);
  bool CloseLineInvalid;
  const unsigned CloseLine = SourceMgr.getPresumedLineNumber(
                                              HET->getLocation(),
                                              &CloseLineInvalid);

  if (OpenLineInvalid || CloseLineInvalid || OpenLine == CloseLine) {
    Diag(HST->getLocation(), diag::warn_doc_html_start_end_mismatch)
      << HST->getTagName() << HET->getTagName()
      << HST->getSourceRange() << HET->getSourceRange();
    HST->setIsMalformed();
  } else {
    Diag(HST->getLocation(), diag::warn_doc_html_start_end_mismatch)
      << HST->getTagName() << HET->getTagName()
      << HST->getSourceRange();
    Diag(HET->getLocation(), diag::note_doc_html_end_tag)
      << HET->getSourceRange();
    HST->setIsMalformed();
  }
}

return HET;
544}

546FullComment *Sema::actOnFullComment(
                            ArrayRef<BlockContentComment *> Blocks) {
FullComment *FC = new (Allocator) FullComment(Blocks, ThisDeclInfo);
1
Calling 'operator new<llvm::MallocAllocator, 4096UL, 4096UL, 128UL>'→
resolveParamCommandIndexes(FC);

// Complain about HTML tags that are not closed.
while (!HTMLOpenTags.empty()) {
  HTMLStartTagComment *HST = HTMLOpenTags.pop_back_val();
  if (isHTMLEndTagOptional(HST->getTagName()))
    continue;

  Diag(HST->getLocation(), diag::warn_doc_html_missing_end_tag)
    << HST->getTagName() << HST->getSourceRange();
  HST->setIsMalformed();
}

return FC;
563}

565void Sema::checkBlockCommandEmptyParagraph(BlockCommandComment *Command) {
if (Traits.getCommandInfo(Command->getCommandID())->IsEmptyParagraphAllowed)
  return;

ParagraphComment *Paragraph = Command->getParagraph();
if (Paragraph->isWhitespace()) {
  SourceLocation DiagLoc;
  if (Command->getNumArgs() > 0)
    DiagLoc = Command->getArgRange(Command->getNumArgs() - 1).getEnd();
  if (!DiagLoc.isValid())
    DiagLoc = Command->getCommandNameRange(Traits).getEnd();
  Diag(DiagLoc, diag::warn_doc_block_command_empty_paragraph)
    << Command->getCommandMarker()
    << Command->getCommandName(Traits)
    << Command->getSourceRange();
}
581}

583void Sema::checkReturnsCommand(const BlockCommandComment *Command) {
if (!Traits.getCommandInfo(Command->getCommandID())->IsReturnsCommand)
  return;

assert(ThisDeclInfo && "should not call this check on a bare comment")((void)0);

// We allow the return command for all @properties because it can be used
// to document the value that the property getter returns.
if (isObjCPropertyDecl())
  return;
if (isFunctionDecl() || isFunctionOrBlockPointerVarLikeDecl()) {
  assert(!ThisDeclInfo->ReturnType.isNull() &&((void)0)
         "should have a valid return type")((void)0);
  if (ThisDeclInfo->ReturnType->isVoidType()) {
    unsigned DiagKind;
    switch (ThisDeclInfo->CommentDecl->getKind()) {
    default:
      if (ThisDeclInfo->IsObjCMethod)
        DiagKind = 3;
      else
        DiagKind = 0;
      break;
    case Decl::CXXConstructor:
      DiagKind = 1;
      break;
    case Decl::CXXDestructor:
      DiagKind = 2;
      break;
    }
    Diag(Command->getLocation(),
         diag::warn_doc_returns_attached_to_a_void_function)
      << Command->getCommandMarker()
      << Command->getCommandName(Traits)
      << DiagKind
      << Command->getSourceRange();
  }
  return;
}

Diag(Command->getLocation(),
     diag::warn_doc_returns_not_attached_to_a_function_decl)
  << Command->getCommandMarker()
  << Command->getCommandName(Traits)
  << Command->getSourceRange();
627}

629void Sema::checkBlockCommandDuplicate(const BlockCommandComment *Command) {
const CommandInfo *Info = Traits.getCommandInfo(Command->getCommandID());
const BlockCommandComment *PrevCommand = nullptr;
if (Info->IsBriefCommand) {
  if (!BriefCommand) {
    BriefCommand = Command;
    return;
  }
  PrevCommand = BriefCommand;
} else if (Info->IsHeaderfileCommand) {
  if (!HeaderfileCommand) {
    HeaderfileCommand = Command;
    return;
  }
  PrevCommand = HeaderfileCommand;
} else {
  // We don't want to check this command for duplicates.
  return;
}
StringRef CommandName = Command->getCommandName(Traits);
StringRef PrevCommandName = PrevCommand->getCommandName(Traits);
Diag(Command->getLocation(), diag::warn_doc_block_command_duplicate)
    << Command->getCommandMarker()
    << CommandName
    << Command->getSourceRange();
if (CommandName == PrevCommandName)
  Diag(PrevCommand->getLocation(), diag::note_doc_block_command_previous)
      << PrevCommand->getCommandMarker()
      << PrevCommandName
      << PrevCommand->getSourceRange();
else
  Diag(PrevCommand->getLocation(),
       diag::note_doc_block_command_previous_alias)
      << PrevCommand->getCommandMarker()
      << PrevCommandName
      << CommandName;
665}

667void Sema::checkDeprecatedCommand(const BlockCommandComment *Command) {
if (!Traits.getCommandInfo(Command->getCommandID())->IsDeprecatedCommand)
  return;

assert(ThisDeclInfo && "should not call this check on a bare comment")((void)0);

const Decl *D = ThisDeclInfo->CommentDecl;
if (!D)
  return;

if (D->hasAttr<DeprecatedAttr>() ||
    D->hasAttr<AvailabilityAttr>() ||
    D->hasAttr<UnavailableAttr>())
  return;

Diag(Command->getLocation(), diag::warn_doc_deprecated_not_sync)
    << Command->getSourceRange() << Command->getCommandMarker();

// Try to emit a fixit with a deprecation attribute.
if (const FunctionDecl *FD = dyn_cast<FunctionDecl>(D)) {
  // Don't emit a Fix-It for non-member function definitions.  GCC does not
  // accept attributes on them.
  const DeclContext *Ctx = FD->getDeclContext();
  if ((!Ctx || !Ctx->isRecord()) &&
      FD->doesThisDeclarationHaveABody())
    return;

  const LangOptions &LO = FD->getLangOpts();
  const bool DoubleSquareBracket = LO.CPlusPlus14 || LO.C2x;
  StringRef AttributeSpelling =
      DoubleSquareBracket ? "[[deprecated]]" : "__attribute__((deprecated))";
  if (PP) {
    // Try to find a replacement macro:
    // - In C2x/C++14 we prefer [[deprecated]].
    // - If not found or an older C/C++ look for __attribute__((deprecated)).
    StringRef MacroName;
    if (DoubleSquareBracket) {
      TokenValue Tokens[] = {tok::l_square, tok::l_square,
                             PP->getIdentifierInfo("deprecated"),
                             tok::r_square, tok::r_square};
      MacroName = PP->getLastMacroWithSpelling(FD->getLocation(), Tokens);
      if (!MacroName.empty())
        AttributeSpelling = MacroName;
    }

    if (MacroName.empty()) {
      TokenValue Tokens[] = {
          tok::kw___attribute, tok::l_paren,
          tok::l_paren,        PP->getIdentifierInfo("deprecated"),
          tok::r_paren,        tok::r_paren};
      StringRef MacroName =
          PP->getLastMacroWithSpelling(FD->getLocation(), Tokens);
      if (!MacroName.empty())
        AttributeSpelling = MacroName;
    }
  }

  SmallString<64> TextToInsert = AttributeSpelling;
  TextToInsert += " ";
  SourceLocation Loc = FD->getSourceRange().getBegin();
  Diag(Loc, diag::note_add_deprecation_attr)
      << FixItHint::CreateInsertion(Loc, TextToInsert);
}
730}

732void Sema::resolveParamCommandIndexes(const FullComment *FC) {
if (!isFunctionDecl()) {
  // We already warned that \\param commands are not attached to a function
  // decl.
  return;
}

SmallVector<ParamCommandComment *, 8> UnresolvedParamCommands;

// Comment AST nodes that correspond to \c ParamVars for which we have
// found a \\param command or NULL if no documentation was found so far.
SmallVector<ParamCommandComment *, 8> ParamVarDocs;

ArrayRef<const ParmVarDecl *> ParamVars = getParamVars();
ParamVarDocs.resize(ParamVars.size(), nullptr);

// First pass over all \\param commands: resolve all parameter names.
for (Comment::child_iterator I = FC->child_begin(), E = FC->child_end();
     I != E; ++I) {
  ParamCommandComment *PCC = dyn_cast<ParamCommandComment>(*I);
  if (!PCC || !PCC->hasParamName())
    continue;
  StringRef ParamName = PCC->getParamNameAsWritten();

  // Check that referenced parameter name is in the function decl.
  const unsigned ResolvedParamIndex = resolveParmVarReference(ParamName,
                                                              ParamVars);
  if (ResolvedParamIndex == ParamCommandComment::VarArgParamIndex) {
    PCC->setIsVarArgParam();
    continue;
  }
  if (ResolvedParamIndex == ParamCommandComment::InvalidParamIndex) {
    UnresolvedParamCommands.push_back(PCC);
    continue;
  }
  PCC->setParamIndex(ResolvedParamIndex);
  if (ParamVarDocs[ResolvedParamIndex]) {
    SourceRange ArgRange = PCC->getParamNameRange();
    Diag(ArgRange.getBegin(), diag::warn_doc_param_duplicate)
      << ParamName << ArgRange;
    ParamCommandComment *PrevCommand = ParamVarDocs[ResolvedParamIndex];
    Diag(PrevCommand->getLocation(), diag::note_doc_param_previous)
      << PrevCommand->getParamNameRange();
  }
  ParamVarDocs[ResolvedParamIndex] = PCC;
}

// Find parameter declarations that have no corresponding \\param.
SmallVector<const ParmVarDecl *, 8> OrphanedParamDecls;
for (unsigned i = 0, e = ParamVarDocs.size(); i != e; ++i) {
  if (!ParamVarDocs[i])
    OrphanedParamDecls.push_back(ParamVars[i]);
}

// Second pass over unresolved \\param commands: do typo correction.
// Suggest corrections from a set of parameter declarations that have no
// corresponding \\param.
for (unsigned i = 0, e = UnresolvedParamCommands.size(); i != e; ++i) {
  const ParamCommandComment *PCC = UnresolvedParamCommands[i];

  SourceRange ArgRange = PCC->getParamNameRange();
  StringRef ParamName = PCC->getParamNameAsWritten();
  Diag(ArgRange.getBegin(), diag::warn_doc_param_not_found)
    << ParamName << ArgRange;

  // All parameters documented -- can't suggest a correction.
  if (OrphanedParamDecls.size() == 0)
    continue;

  unsigned CorrectedParamIndex = ParamCommandComment::InvalidParamIndex;
  if (OrphanedParamDecls.size() == 1) {
    // If one parameter is not documented then that parameter is the only
    // possible suggestion.
    CorrectedParamIndex = 0;
  } else {
    // Do typo correction.
    CorrectedParamIndex = correctTypoInParmVarReference(ParamName,
                                                        OrphanedParamDecls);
  }
  if (CorrectedParamIndex != ParamCommandComment::InvalidParamIndex) {
    const ParmVarDecl *CorrectedPVD = OrphanedParamDecls[CorrectedParamIndex];
    if (const IdentifierInfo *CorrectedII = CorrectedPVD->getIdentifier())
      Diag(ArgRange.getBegin(), diag::note_doc_param_name_suggestion)
        << CorrectedII->getName()
        << FixItHint::CreateReplacement(ArgRange, CorrectedII->getName());
  }
}
819}

821bool Sema::isFunctionDecl() {
if (!ThisDeclInfo)
  return false;
if (!ThisDeclInfo->IsFilled)
  inspectThisDecl();
return ThisDeclInfo->getKind() == DeclInfo::FunctionKind;
827}

829bool Sema::isAnyFunctionDecl() {
return isFunctionDecl() && ThisDeclInfo->CurrentDecl &&
       isa<FunctionDecl>(ThisDeclInfo->CurrentDecl);
832}

834bool Sema::isFunctionOrMethodVariadic() {
if (!isFunctionDecl() || !ThisDeclInfo->CurrentDecl)
  return false;
if (const FunctionDecl *FD =
      dyn_cast<FunctionDecl>(ThisDeclInfo->CurrentDecl))
  return FD->isVariadic();
if (const FunctionTemplateDecl *FTD =
      dyn_cast<FunctionTemplateDecl>(ThisDeclInfo->CurrentDecl))
  return FTD->getTemplatedDecl()->isVariadic();
if (const ObjCMethodDecl *MD =
      dyn_cast<ObjCMethodDecl>(ThisDeclInfo->CurrentDecl))
  return MD->isVariadic();
if (const TypedefNameDecl *TD =
        dyn_cast<TypedefNameDecl>(ThisDeclInfo->CurrentDecl)) {
  QualType Type = TD->getUnderlyingType();
  if (Type->isFunctionPointerType() || Type->isBlockPointerType())
    Type = Type->getPointeeType();
  if (const auto *FT = Type->getAs<FunctionProtoType>())
    return FT->isVariadic();
}
return false;
855}

857bool Sema::isObjCMethodDecl() {
return isFunctionDecl() && ThisDeclInfo->CurrentDecl &&
       isa<ObjCMethodDecl>(ThisDeclInfo->CurrentDecl);
860}

862bool Sema::isFunctionPointerVarDecl() {
if (!ThisDeclInfo)
  return false;
if (!ThisDeclInfo->IsFilled)
  inspectThisDecl();
if (ThisDeclInfo->getKind() == DeclInfo::VariableKind) {
  if (const VarDecl *VD = dyn_cast_or_null<VarDecl>(ThisDeclInfo->CurrentDecl)) {
    QualType QT = VD->getType();
    return QT->isFunctionPointerType();
  }
}
return false;
874}

876bool Sema::isFunctionOrBlockPointerVarLikeDecl() {
if (!ThisDeclInfo)
  return false;
if (!ThisDeclInfo->IsFilled)
  inspectThisDecl();
if (ThisDeclInfo->getKind() != DeclInfo::VariableKind ||
    !ThisDeclInfo->CurrentDecl)
  return false;
QualType QT;
if (const auto *VD = dyn_cast<DeclaratorDecl>(ThisDeclInfo->CurrentDecl))
  QT = VD->getType();
else if (const auto *PD =
             dyn_cast<ObjCPropertyDecl>(ThisDeclInfo->CurrentDecl))
  QT = PD->getType();
else
  return false;
// We would like to warn about the 'returns'/'param' commands for
// variables that don't directly specify the function type, so type aliases
// can be ignored.
if (QT->getAs<TypedefType>())
  return false;
if (const auto *P = QT->getAs<PointerType>())
  if (P->getPointeeType()->getAs<TypedefType>())
    return false;
if (const auto *P = QT->getAs<BlockPointerType>())
  if (P->getPointeeType()->getAs<TypedefType>())
    return false;
return QT->isFunctionPointerType() || QT->isBlockPointerType();
904}

906bool Sema::isObjCPropertyDecl() {
if (!ThisDeclInfo)
  return false;
if (!ThisDeclInfo->IsFilled)
  inspectThisDecl();
return ThisDeclInfo->CurrentDecl->getKind() == Decl::ObjCProperty;
912}

914bool Sema::isTemplateOrSpecialization() {
if (!ThisDeclInfo)
  return false;
if (!ThisDeclInfo->IsFilled)
  inspectThisDecl();
return ThisDeclInfo->getTemplateKind() != DeclInfo::NotTemplate;
920}

922bool Sema::isRecordLikeDecl() {
if (!ThisDeclInfo)
  return false;
if (!ThisDeclInfo->IsFilled)
  inspectThisDecl();
return isUnionDecl() || isClassOrStructDecl() || isObjCInterfaceDecl() ||
       isObjCProtocolDecl();
929}

931bool Sema::isUnionDecl() {
if (!ThisDeclInfo)
  return false;
if (!ThisDeclInfo->IsFilled)
  inspectThisDecl();
if (const RecordDecl *RD =
      dyn_cast_or_null<RecordDecl>(ThisDeclInfo->CurrentDecl))
  return RD->isUnion();
return false;
940}
941static bool isClassOrStructDeclImpl(const Decl *D) {
if (auto *record = dyn_cast_or_null<RecordDecl>(D))
  return !record->isUnion();

return false;
946}

948bool Sema::isClassOrStructDecl() {
if (!ThisDeclInfo)
  return false;
if (!ThisDeclInfo->IsFilled)
  inspectThisDecl();

if (!ThisDeclInfo->CurrentDecl)
  return false;

return isClassOrStructDeclImpl(ThisDeclInfo->CurrentDecl);
958}

960bool Sema::isClassOrStructOrTagTypedefDecl() {
if (!ThisDeclInfo)
  return false;
if (!ThisDeclInfo->IsFilled)
  inspectThisDecl();

if (!ThisDeclInfo->CurrentDecl)
  return false;

if (isClassOrStructDeclImpl(ThisDeclInfo->CurrentDecl))
  return true;

if (auto *ThisTypedefDecl = dyn_cast<TypedefDecl>(ThisDeclInfo->CurrentDecl)) {
  auto UnderlyingType = ThisTypedefDecl->getUnderlyingType();
  if (auto ThisElaboratedType = dyn_cast<ElaboratedType>(UnderlyingType)) {
    auto DesugaredType = ThisElaboratedType->desugar();
    if (auto *DesugaredTypePtr = DesugaredType.getTypePtrOrNull()) {
      if (auto *ThisRecordType = dyn_cast<RecordType>(DesugaredTypePtr)) {
        return isClassOrStructDeclImpl(ThisRecordType->getAsRecordDecl());
      }
    }
  }
}

return false;
985}

987bool Sema::isClassTemplateDecl() {
if (!ThisDeclInfo)
  return false;
if (!ThisDeclInfo->IsFilled)
  inspectThisDecl();
return ThisDeclInfo->CurrentDecl &&
        (isa<ClassTemplateDecl>(ThisDeclInfo->CurrentDecl));
994}

996bool Sema::isFunctionTemplateDecl() {
if (!ThisDeclInfo)
  return false;
if (!ThisDeclInfo->IsFilled)
  inspectThisDecl();
return ThisDeclInfo->CurrentDecl &&
       (isa<FunctionTemplateDecl>(ThisDeclInfo->CurrentDecl));
1003}

1005bool Sema::isObjCInterfaceDecl() {
if (!ThisDeclInfo)
  return false;
if (!ThisDeclInfo->IsFilled)
  inspectThisDecl();
return ThisDeclInfo->CurrentDecl &&
       isa<ObjCInterfaceDecl>(ThisDeclInfo->CurrentDecl);
1012}

1014bool Sema::isObjCProtocolDecl() {
if (!ThisDeclInfo)
  return false;
if (!ThisDeclInfo->IsFilled)
  inspectThisDecl();
return ThisDeclInfo->CurrentDecl &&
       isa<ObjCProtocolDecl>(ThisDeclInfo->CurrentDecl);
1021}

1023ArrayRef<const ParmVarDecl *> Sema::getParamVars() {
if (!ThisDeclInfo->IsFilled)
  inspectThisDecl();
return ThisDeclInfo->ParamVars;
1027}

1029void Sema::inspectThisDecl() {
ThisDeclInfo->fill();
1031}

1033unsigned Sema::resolveParmVarReference(StringRef Name,
                                     ArrayRef<const ParmVarDecl *> ParamVars) {
for (unsigned i = 0, e = ParamVars.size(); i != e; ++i) {
  const IdentifierInfo *II = ParamVars[i]->getIdentifier();
  if (II && II->getName() == Name)
    return i;
}
if (Name == "..." && isFunctionOrMethodVariadic())
  return ParamCommandComment::VarArgParamIndex;
return ParamCommandComment::InvalidParamIndex;
1043}

1045namespace {
1046class SimpleTypoCorrector {
const NamedDecl *BestDecl;

StringRef Typo;
const unsigned MaxEditDistance;

unsigned BestEditDistance;
unsigned BestIndex;
unsigned NextIndex;

1056public:
explicit SimpleTypoCorrector(StringRef Typo)
    : BestDecl(nullptr), Typo(Typo), MaxEditDistance((Typo.size() + 2) / 3),
      BestEditDistance(MaxEditDistance + 1), BestIndex(0), NextIndex(0) {}

void addDecl(const NamedDecl *ND);

const NamedDecl *getBestDecl() const {
  if (BestEditDistance > MaxEditDistance)
    return nullptr;

  return BestDecl;
}

unsigned getBestDeclIndex() const {
  assert(getBestDecl())((void)0);
  return BestIndex;
}
1074};

1076void SimpleTypoCorrector::addDecl(const NamedDecl *ND) {
unsigned CurrIndex = NextIndex++;

const IdentifierInfo *II = ND->getIdentifier();
if (!II)
  return;

StringRef Name = II->getName();
unsigned MinPossibleEditDistance = abs((int)Name.size() - (int)Typo.size());
if (MinPossibleEditDistance > 0 &&
    Typo.size() / MinPossibleEditDistance < 3)
  return;

unsigned EditDistance = Typo.edit_distance(Name, true, MaxEditDistance);
if (EditDistance < BestEditDistance) {
  BestEditDistance = EditDistance;
  BestDecl = ND;
  BestIndex = CurrIndex;
}
1095}
1096} // end anonymous namespace

1098unsigned Sema::correctTypoInParmVarReference(
                                  StringRef Typo,
                                  ArrayRef<const ParmVarDecl *> ParamVars) {
SimpleTypoCorrector Corrector(Typo);
for (unsigned i = 0, e = ParamVars.size(); i != e; ++i)
  Corrector.addDecl(ParamVars[i]);
if (Corrector.getBestDecl())
  return Corrector.getBestDeclIndex();
else
  return ParamCommandComment::InvalidParamIndex;
1108}

1110namespace {
1111bool ResolveTParamReferenceHelper(
                          StringRef Name,
                          const TemplateParameterList *TemplateParameters,
                          SmallVectorImpl<unsigned> *Position) {
for (unsigned i = 0, e = TemplateParameters->size(); i != e; ++i) {
  const NamedDecl *Param = TemplateParameters->getParam(i);
  const IdentifierInfo *II = Param->getIdentifier();
  if (II && II->getName() == Name) {
    Position->push_back(i);
    return true;
  }

  if (const TemplateTemplateParmDecl *TTP =
          dyn_cast<TemplateTemplateParmDecl>(Param)) {
    Position->push_back(i);
    if (ResolveTParamReferenceHelper(Name, TTP->getTemplateParameters(),
                                     Position))
      return true;
    Position->pop_back();
  }
}
return false;
1133}
1134} // end anonymous namespace

1136bool Sema::resolveTParamReference(
                          StringRef Name,
                          const TemplateParameterList *TemplateParameters,
                          SmallVectorImpl<unsigned> *Position) {
Position->clear();
if (!TemplateParameters)
  return false;

return ResolveTParamReferenceHelper(Name, TemplateParameters, Position);
1145}

1147namespace {
1148void CorrectTypoInTParamReferenceHelper(
                          const TemplateParameterList *TemplateParameters,
                          SimpleTypoCorrector &Corrector) {
for (unsigned i = 0, e = TemplateParameters->size(); i != e; ++i) {
  const NamedDecl *Param = TemplateParameters->getParam(i);
  Corrector.addDecl(Param);

  if (const TemplateTemplateParmDecl *TTP =
          dyn_cast<TemplateTemplateParmDecl>(Param))
    CorrectTypoInTParamReferenceHelper(TTP->getTemplateParameters(),
                                       Corrector);
}
1160}
1161} // end anonymous namespace

1163StringRef Sema::correctTypoInTParamReference(
                          StringRef Typo,
                          const TemplateParameterList *TemplateParameters) {
SimpleTypoCorrector Corrector(Typo);
CorrectTypoInTParamReferenceHelper(TemplateParameters, Corrector);
if (const NamedDecl *ND = Corrector.getBestDecl()) {
  const IdentifierInfo *II = ND->getIdentifier();
  assert(II && "SimpleTypoCorrector should not return this decl")((void)0);
  return II->getName();
}
return StringRef();
1174}

1176InlineCommandComment::RenderKind
1177Sema::getInlineCommandRenderKind(StringRef Name) const {
assert(Traits.getCommandInfo(Name)->IsInlineCommand)((void)0);

return llvm::StringSwitch<InlineCommandComment::RenderKind>(Name)
    .Case("b", InlineCommandComment::RenderBold)
    .Cases("c", "p", InlineCommandComment::RenderMonospaced)
    .Cases("a", "e", "em", InlineCommandComment::RenderEmphasized)
    .Case("anchor", InlineCommandComment::RenderAnchor)
    .Default(InlineCommandComment::RenderNormal);
1186}

1188} // end namespace comments
1189} // end namespace clang

←

/usr/src/gnu/usr.bin/clang/libclangAST/../../../llvm/llvm/include/llvm/Support/Allocator.h

→

1//===- Allocator.h - Simple memory allocation abstraction -------*- C++ -*-===//
2//
3// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
4// See https://llvm.org/LICENSE.txt for license information.
5// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
6//
7//===----------------------------------------------------------------------===//
8/// \file
9///
10/// This file defines the BumpPtrAllocator interface. BumpPtrAllocator conforms
11/// to the LLVM "Allocator" concept and is similar to MallocAllocator, but
12/// objects cannot be deallocated. Their lifetime is tied to the lifetime of the
13/// allocator.
14///
15//===----------------------------------------------------------------------===//

17#ifndef LLVM_SUPPORT_ALLOCATOR_H
18#define LLVM_SUPPORT_ALLOCATOR_H

20#include "llvm/ADT/Optional.h"
21#include "llvm/ADT/SmallVector.h"
22#include "llvm/Support/Alignment.h"
23#include "llvm/Support/AllocatorBase.h"
24#include "llvm/Support/Compiler.h"
25#include "llvm/Support/ErrorHandling.h"
26#include "llvm/Support/MathExtras.h"
27#include "llvm/Support/MemAlloc.h"
28#include <algorithm>
29#include <cassert>
30#include <cstddef>
31#include <cstdint>
32#include <cstdlib>
33#include <iterator>
34#include <type_traits>
35#include <utility>

37namespace llvm {

39namespace detail {

41// We call out to an external function to actually print the message as the
42// printing code uses Allocator.h in its implementation.
43void printBumpPtrAllocatorStats(unsigned NumSlabs, size_t BytesAllocated,
                              size_t TotalMemory);

46} // end namespace detail

48/// Allocate memory in an ever growing pool, as if by bump-pointer.
49///
50/// This isn't strictly a bump-pointer allocator as it uses backing slabs of
51/// memory rather than relying on a boundless contiguous heap. However, it has
52/// bump-pointer semantics in that it is a monotonically growing pool of memory
53/// where every allocation is found by merely allocating the next N bytes in
54/// the slab, or the next N bytes in the next slab.
55///
56/// Note that this also has a threshold for forcing allocations above a certain
57/// size into their own slab.
58///
59/// The BumpPtrAllocatorImpl template defaults to using a MallocAllocator
60/// object, which wraps malloc, to allocate memory, but it can be changed to
61/// use a custom allocator.
62///
63/// The GrowthDelay specifies after how many allocated slabs the allocator
64/// increases the size of the slabs.
65template <typename AllocatorT = MallocAllocator, size_t SlabSize = 4096,
        size_t SizeThreshold = SlabSize, size_t GrowthDelay = 128>
67class BumpPtrAllocatorImpl
  : public AllocatorBase<BumpPtrAllocatorImpl<AllocatorT, SlabSize,
                                              SizeThreshold, GrowthDelay>>,
    private AllocatorT {
71public:
static_assert(SizeThreshold <= SlabSize,
              "The SizeThreshold must be at most the SlabSize to ensure "
              "that objects larger than a slab go into their own memory "
              "allocation.");
static_assert(GrowthDelay > 0,
              "GrowthDelay must be at least 1 which already increases the"
              "slab size after each allocated slab.");

BumpPtrAllocatorImpl() = default;

template <typename T>
BumpPtrAllocatorImpl(T &&Allocator)
    : AllocatorT(std::forward<T &&>(Allocator)) {}

// Manually implement a move constructor as we must clear the old allocator's
// slabs as a matter of correctness.
BumpPtrAllocatorImpl(BumpPtrAllocatorImpl &&Old)
    : AllocatorT(static_cast<AllocatorT &&>(Old)), CurPtr(Old.CurPtr),
      End(Old.End), Slabs(std::move(Old.Slabs)),
      CustomSizedSlabs(std::move(Old.CustomSizedSlabs)),
      BytesAllocated(Old.BytesAllocated), RedZoneSize(Old.RedZoneSize) {
  Old.CurPtr = Old.End = nullptr;
  Old.BytesAllocated = 0;
  Old.Slabs.clear();
  Old.CustomSizedSlabs.clear();
}

~BumpPtrAllocatorImpl() {
  DeallocateSlabs(Slabs.begin(), Slabs.end());
  DeallocateCustomSizedSlabs();
}

BumpPtrAllocatorImpl &operator=(BumpPtrAllocatorImpl &&RHS) {
  DeallocateSlabs(Slabs.begin(), Slabs.end());
  DeallocateCustomSizedSlabs();

  CurPtr = RHS.CurPtr;
  End = RHS.End;
  BytesAllocated = RHS.BytesAllocated;
  RedZoneSize = RHS.RedZoneSize;
  Slabs = std::move(RHS.Slabs);
  CustomSizedSlabs = std::move(RHS.CustomSizedSlabs);
  AllocatorT::operator=(static_cast<AllocatorT &&>(RHS));

  RHS.CurPtr = RHS.End = nullptr;
  RHS.BytesAllocated = 0;
  RHS.Slabs.clear();
  RHS.CustomSizedSlabs.clear();
  return *this;
}

/// Deallocate all but the current slab and reset the current pointer
/// to the beginning of it, freeing all memory allocated so far.
void Reset() {
  // Deallocate all but the first slab, and deallocate all custom-sized slabs.
  DeallocateCustomSizedSlabs();
  CustomSizedSlabs.clear();

  if (Slabs.empty())
    return;

  // Reset the state.
  BytesAllocated = 0;
  CurPtr = (char *)Slabs.front();
  End = CurPtr + SlabSize;

  __asan_poison_memory_region(*Slabs.begin(), computeSlabSize(0));
  DeallocateSlabs(std::next(Slabs.begin()), Slabs.end());
  Slabs.erase(std::next(Slabs.begin()), Slabs.end());
}

/// Allocate space at the specified alignment.
LLVM_ATTRIBUTE_RETURNS_NONNULL__attribute__((returns_nonnull)) LLVM_ATTRIBUTE_RETURNS_NOALIAS__attribute__((__malloc__)) void *
Allocate(size_t Size, Align Alignment) {
  // Keep track of how many bytes we've allocated.
  BytesAllocated += Size;

  size_t Adjustment = offsetToAlignedAddr(CurPtr, Alignment);
4
←
Calling 'offsetToAlignedAddr'→
  assert(Adjustment + Size >= Size && "Adjustment + Size must not overflow")((void)0);

  size_t SizeToAllocate = Size;
153#if LLVM_ADDRESS_SANITIZER_BUILD0
  // Add trailing bytes as a "red zone" under ASan.
  SizeToAllocate += RedZoneSize;
156#endif

  // Check if we have enough space.
  if (Adjustment + SizeToAllocate <= size_t(End - CurPtr)) {
    char *AlignedPtr = CurPtr + Adjustment;
    CurPtr = AlignedPtr + SizeToAllocate;
    // Update the allocation point of this memory block in MemorySanitizer.
    // Without this, MemorySanitizer messages for values originated from here
    // will point to the allocation of the entire slab.
    __msan_allocated_memory(AlignedPtr, Size);
    // Similarly, tell ASan about this space.
    __asan_unpoison_memory_region(AlignedPtr, Size);
    return AlignedPtr;
  }

  // If Size is really big, allocate a separate slab for it.
  size_t PaddedSize = SizeToAllocate + Alignment.value() - 1;
  if (PaddedSize > SizeThreshold) {
    void *NewSlab =
        AllocatorT::Allocate(PaddedSize, alignof(std::max_align_t));
    // We own the new slab and don't want anyone reading anyting other than
    // pieces returned from this method.  So poison the whole slab.
    __asan_poison_memory_region(NewSlab, PaddedSize);
    CustomSizedSlabs.push_back(std::make_pair(NewSlab, PaddedSize));

    uintptr_t AlignedAddr = alignAddr(NewSlab, Alignment);
    assert(AlignedAddr + Size <= (uintptr_t)NewSlab + PaddedSize)((void)0);
    char *AlignedPtr = (char*)AlignedAddr;
    __msan_allocated_memory(AlignedPtr, Size);
    __asan_unpoison_memory_region(AlignedPtr, Size);
    return AlignedPtr;
  }

  // Otherwise, start a new slab and try again.
  StartNewSlab();
  uintptr_t AlignedAddr = alignAddr(CurPtr, Alignment);
  assert(AlignedAddr + SizeToAllocate <= (uintptr_t)End &&((void)0)
         "Unable to allocate memory!")((void)0);
  char *AlignedPtr = (char*)AlignedAddr;
  CurPtr = AlignedPtr + SizeToAllocate;
  __msan_allocated_memory(AlignedPtr, Size);
  __asan_unpoison_memory_region(AlignedPtr, Size);
  return AlignedPtr;
}

inline LLVM_ATTRIBUTE_RETURNS_NONNULL__attribute__((returns_nonnull)) LLVM_ATTRIBUTE_RETURNS_NOALIAS__attribute__((__malloc__)) void *
Allocate(size_t Size, size_t Alignment) {
  assert(Alignment > 0 && "0-byte alignment is not allowed. Use 1 instead.")((void)0);
  return Allocate(Size, Align(Alignment));
3
←
Calling 'BumpPtrAllocatorImpl::Allocate'→
}

// Pull in base class overloads.
using AllocatorBase<BumpPtrAllocatorImpl>::Allocate;

// Bump pointer allocators are expected to never free their storage; and
// clients expect pointers to remain valid for non-dereferencing uses even
// after deallocation.
void Deallocate(const void *Ptr, size_t Size, size_t /*Alignment*/) {
  __asan_poison_memory_region(Ptr, Size);
}

// Pull in base class overloads.
using AllocatorBase<BumpPtrAllocatorImpl>::Deallocate;

size_t GetNumSlabs() const { return Slabs.size() + CustomSizedSlabs.size(); }

/// \return An index uniquely and reproducibly identifying
/// an input pointer \p Ptr in the given allocator.
/// The returned value is negative iff the object is inside a custom-size
/// slab.
/// Returns an empty optional if the pointer is not found in the allocator.
llvm::Optional<int64_t> identifyObject(const void *Ptr) {
  const char *P = static_cast<const char *>(Ptr);
  int64_t InSlabIdx = 0;
  for (size_t Idx = 0, E = Slabs.size(); Idx < E; Idx++) {
    const char *S = static_cast<const char *>(Slabs[Idx]);
    if (P >= S && P < S + computeSlabSize(Idx))
      return InSlabIdx + static_cast<int64_t>(P - S);
    InSlabIdx += static_cast<int64_t>(computeSlabSize(Idx));
  }

  // Use negative index to denote custom sized slabs.
  int64_t InCustomSizedSlabIdx = -1;
  for (size_t Idx = 0, E = CustomSizedSlabs.size(); Idx < E; Idx++) {
    const char *S = static_cast<const char *>(CustomSizedSlabs[Idx].first);
    size_t Size = CustomSizedSlabs[Idx].second;
    if (P >= S && P < S + Size)
      return InCustomSizedSlabIdx - static_cast<int64_t>(P - S);
    InCustomSizedSlabIdx -= static_cast<int64_t>(Size);
  }
  return None;
}

/// A wrapper around identifyObject that additionally asserts that
/// the object is indeed within the allocator.
/// \return An index uniquely and reproducibly identifying
/// an input pointer \p Ptr in the given allocator.
int64_t identifyKnownObject(const void *Ptr) {
  Optional<int64_t> Out = identifyObject(Ptr);
  assert(Out && "Wrong allocator used")((void)0);
  return *Out;
}

/// A wrapper around identifyKnownObject. Accepts type information
/// about the object and produces a smaller identifier by relying on
/// the alignment information. Note that sub-classes may have different
/// alignment, so the most base class should be passed as template parameter
/// in order to obtain correct results. For that reason automatic template
/// parameter deduction is disabled.
/// \return An index uniquely and reproducibly identifying
/// an input pointer \p Ptr in the given allocator. This identifier is
/// different from the ones produced by identifyObject and
/// identifyAlignedObject.
template <typename T>
int64_t identifyKnownAlignedObject(const void *Ptr) {
  int64_t Out = identifyKnownObject(Ptr);
  assert(Out % alignof(T) == 0 && "Wrong alignment information")((void)0);
  return Out / alignof(T);
}

size_t getTotalMemory() const {
  size_t TotalMemory = 0;
  for (auto I = Slabs.begin(), E = Slabs.end(); I != E; ++I)
    TotalMemory += computeSlabSize(std::distance(Slabs.begin(), I));
  for (auto &PtrAndSize : CustomSizedSlabs)
    TotalMemory += PtrAndSize.second;
  return TotalMemory;
}

size_t getBytesAllocated() const { return BytesAllocated; }

void setRedZoneSize(size_t NewSize) {
  RedZoneSize = NewSize;
}

void PrintStats() const {
  detail::printBumpPtrAllocatorStats(Slabs.size(), BytesAllocated,
                                     getTotalMemory());
}

296private:
/// The current pointer into the current slab.
///
/// This points to the next free byte in the slab.
char *CurPtr = nullptr;

/// The end of the current slab.
char *End = nullptr;

/// The slabs allocated so far.
SmallVector<void *, 4> Slabs;

/// Custom-sized slabs allocated for too-large allocation requests.
SmallVector<std::pair<void *, size_t>, 0> CustomSizedSlabs;

/// How many bytes we've allocated.
///
/// Used so that we can compute how much space was wasted.
size_t BytesAllocated = 0;

/// The number of bytes to put between allocations when running under
/// a sanitizer.
size_t RedZoneSize = 1;

static size_t computeSlabSize(unsigned SlabIdx) {
  // Scale the actual allocated slab size based on the number of slabs
  // allocated. Every GrowthDelay slabs allocated, we double
  // the allocated size to reduce allocation frequency, but saturate at
  // multiplying the slab size by 2^30.
  return SlabSize *
         ((size_t)1 << std::min<size_t>(30, SlabIdx / GrowthDelay));
}

/// Allocate a new slab and move the bump pointers over into the new
/// slab, modifying CurPtr and End.
void StartNewSlab() {
  size_t AllocatedSlabSize = computeSlabSize(Slabs.size());

  void *NewSlab =
      AllocatorT::Allocate(AllocatedSlabSize, alignof(std::max_align_t));
  // We own the new slab and don't want anyone reading anything other than
  // pieces returned from this method.  So poison the whole slab.
  __asan_poison_memory_region(NewSlab, AllocatedSlabSize);

  Slabs.push_back(NewSlab);
  CurPtr = (char *)(NewSlab);
  End = ((char *)NewSlab) + AllocatedSlabSize;
}

/// Deallocate a sequence of slabs.
void DeallocateSlabs(SmallVectorImpl<void *>::iterator I,
                     SmallVectorImpl<void *>::iterator E) {
  for (; I != E; ++I) {
    size_t AllocatedSlabSize =
        computeSlabSize(std::distance(Slabs.begin(), I));
    AllocatorT::Deallocate(*I, AllocatedSlabSize, alignof(std::max_align_t));
  }
}

/// Deallocate all memory for custom sized slabs.
void DeallocateCustomSizedSlabs() {
  for (auto &PtrAndSize : CustomSizedSlabs) {
    void *Ptr = PtrAndSize.first;
    size_t Size = PtrAndSize.second;
    AllocatorT::Deallocate(Ptr, Size, alignof(std::max_align_t));
  }
}

template <typename T> friend class SpecificBumpPtrAllocator;
365};

367/// The standard BumpPtrAllocator which just uses the default template
368/// parameters.
369typedef BumpPtrAllocatorImpl<> BumpPtrAllocator;

371/// A BumpPtrAllocator that allows only elements of a specific type to be
372/// allocated.
373///
374/// This allows calling the destructor in DestroyAll() and when the allocator is
375/// destroyed.
376template <typename T> class SpecificBumpPtrAllocator {
BumpPtrAllocator Allocator;

379public:
SpecificBumpPtrAllocator() {
  // Because SpecificBumpPtrAllocator walks the memory to call destructors,
  // it can't have red zones between allocations.
  Allocator.setRedZoneSize(0);
}
SpecificBumpPtrAllocator(SpecificBumpPtrAllocator &&Old)
    : Allocator(std::move(Old.Allocator)) {}
~SpecificBumpPtrAllocator() { DestroyAll(); }

SpecificBumpPtrAllocator &operator=(SpecificBumpPtrAllocator &&RHS) {
  Allocator = std::move(RHS.Allocator);
  return *this;
}

/// Call the destructor of each allocated object and deallocate all but the
/// current slab and reset the current pointer to the beginning of it, freeing
/// all memory allocated so far.
void DestroyAll() {
  auto DestroyElements = [](char *Begin, char *End) {
    assert(Begin == (char *)alignAddr(Begin, Align::Of<T>()))((void)0);
    for (char *Ptr = Begin; Ptr + sizeof(T) <= End; Ptr += sizeof(T))
      reinterpret_cast<T *>(Ptr)->~T();
  };

  for (auto I = Allocator.Slabs.begin(), E = Allocator.Slabs.end(); I != E;
       ++I) {
    size_t AllocatedSlabSize = BumpPtrAllocator::computeSlabSize(
        std::distance(Allocator.Slabs.begin(), I));
    char *Begin = (char *)alignAddr(*I, Align::Of<T>());
    char *End = *I == Allocator.Slabs.back() ? Allocator.CurPtr
                                             : (char *)*I + AllocatedSlabSize;

    DestroyElements(Begin, End);
  }

  for (auto &PtrAndSize : Allocator.CustomSizedSlabs) {
    void *Ptr = PtrAndSize.first;
    size_t Size = PtrAndSize.second;
    DestroyElements((char *)alignAddr(Ptr, Align::Of<T>()),
                    (char *)Ptr + Size);
  }

  Allocator.Reset();
}

/// Allocate space for an array of objects without constructing them.
T *Allocate(size_t num = 1) { return Allocator.Allocate<T>(num); }
427};

429} // end namespace llvm

431template <typename AllocatorT, size_t SlabSize, size_t SizeThreshold,
        size_t GrowthDelay>
433void *
434operator new(size_t Size,
           llvm::BumpPtrAllocatorImpl<AllocatorT, SlabSize, SizeThreshold,
                                      GrowthDelay> &Allocator) {
return Allocator.Allocate(Size, std::min((size_t)llvm::NextPowerOf2(Size),
2
←
Calling 'BumpPtrAllocatorImpl::Allocate'→
                                         alignof(std::max_align_t)));
439}

441template <typename AllocatorT, size_t SlabSize, size_t SizeThreshold,
        size_t GrowthDelay>
443void operator delete(void *,
                   llvm::BumpPtrAllocatorImpl<AllocatorT, SlabSize,
                                              SizeThreshold, GrowthDelay> &) {
446}

448#endif // LLVM_SUPPORT_ALLOCATOR_H

←

/usr/src/gnu/usr.bin/clang/libclangAST/../../../llvm/llvm/include/llvm/Support/Alignment.h

1//===-- llvm/Support/Alignment.h - Useful alignment functions ---*- C++ -*-===//
2//
3// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
4// See https://llvm.org/LICENSE.txt for license information.
5// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
6//
7//===----------------------------------------------------------------------===//
8//
9// This file contains types to represent alignments.
10// They are instrumented to guarantee some invariants are preserved and prevent
11// invalid manipulations.
12//
13// - Align represents an alignment in bytes, it is always set and always a valid
14// power of two, its minimum value is 1 which means no alignment requirements.
15//
16// - MaybeAlign is an optional type, it may be undefined or set. When it's set
17// you can get the underlying Align type by using the getValue() method.
18//
19//===----------------------------------------------------------------------===//
20 
21#ifndef LLVM_SUPPORT_ALIGNMENT_H_
22#define LLVM_SUPPORT_ALIGNMENT_H_
23 
24#include "llvm/ADT/Optional.h"
25#include "llvm/Support/MathExtras.h"
26#include <cassert>
27#ifndef NDEBUG1
28#include <string>
29#endif // NDEBUG
30 
31namespace llvm {
32 
33#define ALIGN_CHECK_ISPOSITIVE(decl)                                           \
34  assert(decl > 0 && (#decl " should be defined"))((void)0)
35 
36/// This struct is a compact representation of a valid (non-zero power of two)
37/// alignment.
38/// It is suitable for use as static global constants.
39struct Align {
40private:
41  uint8_t ShiftValue = 0; /// The log2 of the required alignment.
42                          /// ShiftValue is less than 64 by construction.
43 
44  friend struct MaybeAlign;
45  friend unsigned Log2(Align);
46  friend bool operator==(Align Lhs, Align Rhs);
47  friend bool operator!=(Align Lhs, Align Rhs);
48  friend bool operator<=(Align Lhs, Align Rhs);
49  friend bool operator>=(Align Lhs, Align Rhs);
50  friend bool operator<(Align Lhs, Align Rhs);
51  friend bool operator>(Align Lhs, Align Rhs);
52  friend unsigned encode(struct MaybeAlign A);
53  friend struct MaybeAlign decodeMaybeAlign(unsigned Value);
54 
55  /// A trivial type to allow construction of constexpr Align.
56  /// This is currently needed to workaround a bug in GCC 5.3 which prevents
57  /// definition of constexpr assign operators.
58  /// https://stackoverflow.com/questions/46756288/explicitly-defaulted-function-cannot-be-declared-as-constexpr-because-the-implic
59  /// FIXME: Remove this, make all assign operators constexpr and introduce user
60  /// defined literals when we don't have to support GCC 5.3 anymore.
61  /// https://llvm.org/docs/GettingStarted.html#getting-a-modern-host-c-toolchain
62  struct LogValue {
63    uint8_t Log;
64  };
65 
66public:
67  /// Default is byte-aligned.
68  constexpr Align() = default;
69  /// Do not perform checks in case of copy/move construct/assign, because the
70  /// checks have been performed when building `Other`.
71  constexpr Align(const Align &Other) = default;
72  constexpr Align(Align &&Other) = default;
73  Align &operator=(const Align &Other) = default;
74  Align &operator=(Align &&Other) = default;
75 
76  explicit Align(uint64_t Value) {
77    assert(Value > 0 && "Value must not be 0")((void)0);
78    assert(llvm::isPowerOf2_64(Value) && "Alignment is not a power of 2")((void)0);
79    ShiftValue = Log2_64(Value);
80    assert(ShiftValue < 64 && "Broken invariant")((void)0);
81  }
82 
83  /// This is a hole in the type system and should not be abused.
84  /// Needed to interact with C for instance.
85  uint64_t value() const { return uint64_t(1) << ShiftValue; }
9
←
The result of the left shift is undefined due to shifting by '255', which is greater or equal to the width of type 'uint64_t'
86 
87  /// Allow constructions of constexpr Align.
88  template <size_t kValue> constexpr static LogValue Constant() {
89    return LogValue{static_cast<uint8_t>(CTLog2<kValue>())};
90  }
91 
92  /// Allow constructions of constexpr Align from types.
93  /// Compile time equivalent to Align(alignof(T)).
94  template <typename T> constexpr static LogValue Of() {
95    return Constant<std::alignment_of<T>::value>();
96  }
97 
98  /// Constexpr constructor from LogValue type.
99  constexpr Align(LogValue CA) : ShiftValue(CA.Log) {}
100};
101 
102/// Treats the value 0 as a 1, so Align is always at least 1.
103inline Align assumeAligned(uint64_t Value) {
104  return Value ? Align(Value) : Align();
105}
106 
107/// This struct is a compact representation of a valid (power of two) or
108/// undefined (0) alignment.
109struct MaybeAlign : public llvm::Optional<Align> {
110private:
111  using UP = llvm::Optional<Align>;
112 
113public:
114  /// Default is undefined.
115  MaybeAlign() = default;
116  /// Do not perform checks in case of copy/move construct/assign, because the
117  /// checks have been performed when building `Other`.
118  MaybeAlign(const MaybeAlign &Other) = default;
119  MaybeAlign &operator=(const MaybeAlign &Other) = default;
120  MaybeAlign(MaybeAlign &&Other) = default;
121  MaybeAlign &operator=(MaybeAlign &&Other) = default;
122 
123  /// Use llvm::Optional<Align> constructor.
124  using UP::UP;
125 
126  explicit MaybeAlign(uint64_t Value) {
127    assert((Value == 0 || llvm::isPowerOf2_64(Value)) &&((void)0)
128           "Alignment is neither 0 nor a power of 2")((void)0);
129    if (Value)
130      emplace(Value);
131  }
132 
133  /// For convenience, returns a valid alignment or 1 if undefined.
134  Align valueOrOne() const { return hasValue() ? getValue() : Align(); }
135};
136 
137/// Checks that SizeInBytes is a multiple of the alignment.
138inline bool isAligned(Align Lhs, uint64_t SizeInBytes) {
139  return SizeInBytes % Lhs.value() == 0;
140}
141 
142/// Checks that Addr is a multiple of the alignment.
143inline bool isAddrAligned(Align Lhs, const void *Addr) {
144  return isAligned(Lhs, reinterpret_cast<uintptr_t>(Addr));
145}
146 
147/// Returns a multiple of A needed to store `Size` bytes.
148inline uint64_t alignTo(uint64_t Size, Align A) {
149  const uint64_t Value = A.value();
8
←
Calling 'Align::value'→
150  // The following line is equivalent to `(Size + Value - 1) / Value * Value`.
151 
152  // The division followed by a multiplication can be thought of as a right
153  // shift followed by a left shift which zeros out the extra bits produced in
154  // the bump; `~(Value - 1)` is a mask where all those bits being zeroed out
155  // are just zero.
156 
157  // Most compilers can generate this code but the pattern may be missed when
158  // multiple functions gets inlined.
159  return (Size + Value - 1) & ~(Value - 1U);
160}
161 
162/// If non-zero \p Skew is specified, the return value will be a minimal integer
163/// that is greater than or equal to \p Size and equal to \p A * N + \p Skew for
164/// some integer N. If \p Skew is larger than \p A, its value is adjusted to '\p
165/// Skew mod \p A'.
166///
167/// Examples:
168/// \code
169///   alignTo(5, Align(8), 7) = 7
170///   alignTo(17, Align(8), 1) = 17
171///   alignTo(~0LL, Align(8), 3) = 3
172/// \endcode
173inline uint64_t alignTo(uint64_t Size, Align A, uint64_t Skew) {
174  const uint64_t Value = A.value();
175  Skew %= Value;
176  return ((Size + Value - 1 - Skew) & ~(Value - 1U)) + Skew;
177}
178 
179/// Returns a multiple of A needed to store `Size` bytes.
180/// Returns `Size` if current alignment is undefined.
181inline uint64_t alignTo(uint64_t Size, MaybeAlign A) {
182  return A ? alignTo(Size, A.getValue()) : Size;
183}
184 
185/// Aligns `Addr` to `Alignment` bytes, rounding up.
186inline uintptr_t alignAddr(const void *Addr, Align Alignment) {
187  uintptr_t ArithAddr = reinterpret_cast<uintptr_t>(Addr);
188  assert(static_cast<uintptr_t>(ArithAddr + Alignment.value() - 1) >=((void)0)
189             ArithAddr &&((void)0)
190         "Overflow")((void)0);
191  return alignTo(ArithAddr, Alignment);
192}
193 
194/// Returns the offset to the next integer (mod 2**64) that is greater than
195/// or equal to \p Value and is a multiple of \p Align.
196inline uint64_t offsetToAlignment(uint64_t Value, Align Alignment) {
197  return alignTo(Value, Alignment) - Value;
6
←
The value 255 is assigned to 'A.ShiftValue'→
7
←
Calling 'alignTo'→
198}
199 
200/// Returns the necessary adjustment for aligning `Addr` to `Alignment`
201/// bytes, rounding up.
202inline uint64_t offsetToAlignedAddr(const void *Addr, Align Alignment) {
203  return offsetToAlignment(reinterpret_cast<uintptr_t>(Addr), Alignment);
5
←
Calling 'offsetToAlignment'→
204}
205 
206/// Returns the log2 of the alignment.
207inline unsigned Log2(Align A) { return A.ShiftValue; }
208 
209/// Returns the alignment that satisfies both alignments.
210/// Same semantic as MinAlign.
211inline Align commonAlignment(Align A, Align B) { return std::min(A, B); }
212 
213/// Returns the alignment that satisfies both alignments.
214/// Same semantic as MinAlign.
215inline Align commonAlignment(Align A, uint64_t Offset) {
216  return Align(MinAlign(A.value(), Offset));
217}
218 
219/// Returns the alignment that satisfies both alignments.
220/// Same semantic as MinAlign.
221inline MaybeAlign commonAlignment(MaybeAlign A, MaybeAlign B) {
222  return A && B ? commonAlignment(*A, *B) : A ? A : B;
223}
224 
225/// Returns the alignment that satisfies both alignments.
226/// Same semantic as MinAlign.
227inline MaybeAlign commonAlignment(MaybeAlign A, uint64_t Offset) {
228  return MaybeAlign(MinAlign((*A).value(), Offset));
229}
230 
231/// Returns a representation of the alignment that encodes undefined as 0.
232inline unsigned encode(MaybeAlign A) { return A ? A->ShiftValue + 1 : 0; }
233 
234/// Dual operation of the encode function above.
235inline MaybeAlign decodeMaybeAlign(unsigned Value) {
236  if (Value == 0)
237    return MaybeAlign();
238  Align Out;
239  Out.ShiftValue = Value - 1;
240  return Out;
241}
242 
243/// Returns a representation of the alignment, the encoded value is positive by
244/// definition.
245inline unsigned encode(Align A) { return encode(MaybeAlign(A)); }
246 
247/// Comparisons between Align and scalars. Rhs must be positive.
248inline bool operator==(Align Lhs, uint64_t Rhs) {
249  ALIGN_CHECK_ISPOSITIVE(Rhs);
250  return Lhs.value() == Rhs;
251}
252inline bool operator!=(Align Lhs, uint64_t Rhs) {
253  ALIGN_CHECK_ISPOSITIVE(Rhs);
254  return Lhs.value() != Rhs;
255}
256inline bool operator<=(Align Lhs, uint64_t Rhs) {
257  ALIGN_CHECK_ISPOSITIVE(Rhs);
258  return Lhs.value() <= Rhs;
259}
260inline bool operator>=(Align Lhs, uint64_t Rhs) {
261  ALIGN_CHECK_ISPOSITIVE(Rhs);
262  return Lhs.value() >= Rhs;
263}
264inline bool operator<(Align Lhs, uint64_t Rhs) {
265  ALIGN_CHECK_ISPOSITIVE(Rhs);
266  return Lhs.value() < Rhs;
267}
268inline bool operator>(Align Lhs, uint64_t Rhs) {
269  ALIGN_CHECK_ISPOSITIVE(Rhs);
270  return Lhs.value() > Rhs;
271}
272 
273/// Comparisons between MaybeAlign and scalars.
274inline bool operator==(MaybeAlign Lhs, uint64_t Rhs) {
275  return Lhs ? (*Lhs).value() == Rhs : Rhs == 0;
276}
277inline bool operator!=(MaybeAlign Lhs, uint64_t Rhs) {
278  return Lhs ? (*Lhs).value() != Rhs : Rhs != 0;
279}
280 
281/// Comparisons operators between Align.
282inline bool operator==(Align Lhs, Align Rhs) {
283  return Lhs.ShiftValue == Rhs.ShiftValue;
284}
285inline bool operator!=(Align Lhs, Align Rhs) {
286  return Lhs.ShiftValue != Rhs.ShiftValue;
287}
288inline bool operator<=(Align Lhs, Align Rhs) {
289  return Lhs.ShiftValue <= Rhs.ShiftValue;
290}
291inline bool operator>=(Align Lhs, Align Rhs) {
292  return Lhs.ShiftValue >= Rhs.ShiftValue;
293}
294inline bool operator<(Align Lhs, Align Rhs) {
295  return Lhs.ShiftValue < Rhs.ShiftValue;
296}
297inline bool operator>(Align Lhs, Align Rhs) {
298  return Lhs.ShiftValue > Rhs.ShiftValue;
299}
300 
301// Don't allow relational comparisons with MaybeAlign.
302bool operator<=(Align Lhs, MaybeAlign Rhs) = delete;
303bool operator>=(Align Lhs, MaybeAlign Rhs) = delete;
304bool operator<(Align Lhs, MaybeAlign Rhs) = delete;
305bool operator>(Align Lhs, MaybeAlign Rhs) = delete;
306 
307bool operator<=(MaybeAlign Lhs, Align Rhs) = delete;
308bool operator>=(MaybeAlign Lhs, Align Rhs) = delete;
309bool operator<(MaybeAlign Lhs, Align Rhs) = delete;
310bool operator>(MaybeAlign Lhs, Align Rhs) = delete;
311 
312bool operator<=(MaybeAlign Lhs, MaybeAlign Rhs) = delete;
313bool operator>=(MaybeAlign Lhs, MaybeAlign Rhs) = delete;
314bool operator<(MaybeAlign Lhs, MaybeAlign Rhs) = delete;
315bool operator>(MaybeAlign Lhs, MaybeAlign Rhs) = delete;
316 
317inline Align operator*(Align Lhs, uint64_t Rhs) {
318  assert(Rhs > 0 && "Rhs must be positive")((void)0);
319  return Align(Lhs.value() * Rhs);
320}
321 
322inline MaybeAlign operator*(MaybeAlign Lhs, uint64_t Rhs) {
323  assert(Rhs > 0 && "Rhs must be positive")((void)0);
324  return Lhs ? Lhs.getValue() * Rhs : MaybeAlign();
325}
326 
327inline Align operator/(Align Lhs, uint64_t Divisor) {
328  assert(llvm::isPowerOf2_64(Divisor) &&((void)0)
329         "Divisor must be positive and a power of 2")((void)0);
330  assert(Lhs != 1 && "Can't halve byte alignment")((void)0);
331  return Align(Lhs.value() / Divisor);
332}
333 
334inline MaybeAlign operator/(MaybeAlign Lhs, uint64_t Divisor) {
335  assert(llvm::isPowerOf2_64(Divisor) &&((void)0)
336         "Divisor must be positive and a power of 2")((void)0);
337  return Lhs ? Lhs.getValue() / Divisor : MaybeAlign();
338}
339 
340inline Align max(MaybeAlign Lhs, Align Rhs) {
341  return Lhs && *Lhs > Rhs ? *Lhs : Rhs;
342}
343 
344inline Align max(Align Lhs, MaybeAlign Rhs) {
345  return Rhs && *Rhs > Lhs ? *Rhs : Lhs;
346}
347 
348#ifndef NDEBUG1
349// For usage in LLVM_DEBUG macros.
350inline std::string DebugStr(const Align &A) {
351  return std::to_string(A.value());
352}
353// For usage in LLVM_DEBUG macros.
354inline std::string DebugStr(const MaybeAlign &MA) {
355  if (MA)
356    return std::to_string(MA->value());
357  return "None";
358}
359#endif // NDEBUG
360 
361#undef ALIGN_CHECK_ISPOSITIVE
362 
363} // namespace llvm
364 
365#endif // LLVM_SUPPORT_ALIGNMENT_H_