//===--- AttrImpl.cpp - Classes for representing attributes -----*- 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 contains out-of-line methods for Attr classes.
//
//===----------------------------------------------------------------------===//

#include "clang/AST/ASTContext.h"
#include "clang/AST/ASTStructuralEquivalence.h"
#include "clang/AST/Attr.h"
#include "clang/AST/Expr.h"
#include "clang/AST/Type.h"
#include <optional>
#include <type_traits>
using namespace clang;

void LoopHintAttr::printPrettyPragma(raw_ostream &OS,
                                     const PrintingPolicy &Policy) const {
  unsigned SpellingIndex = getAttributeSpellingListIndex();
  // For "#pragma unroll" and "#pragma nounroll" the string "unroll" or
  // "nounroll" is already emitted as the pragma name.
  if (SpellingIndex == Pragma_nounroll ||
      SpellingIndex == Pragma_nounroll_and_jam)
    return;
  else if (SpellingIndex == Pragma_unroll ||
           SpellingIndex == Pragma_unroll_and_jam) {
    OS << ' ' << getValueString(Policy);
    return;
  }

  assert(SpellingIndex == Pragma_clang_loop && "Unexpected spelling");
  OS << ' ' << getOptionName(option) << getValueString(Policy);
}

// Return a string containing the loop hint argument including the
// enclosing parentheses.
std::string LoopHintAttr::getValueString(const PrintingPolicy &Policy) const {
  std::string ValueName;
  llvm::raw_string_ostream OS(ValueName);
  OS << "(";
  if (state == Numeric)
    value->printPretty(OS, nullptr, Policy);
  else if (state == FixedWidth || state == ScalableWidth) {
    if (value) {
      value->printPretty(OS, nullptr, Policy);
      if (state == ScalableWidth)
        OS << ", scalable";
    } else if (state == ScalableWidth)
      OS << "scalable";
    else
      OS << "fixed";
  } else if (state == Enable)
    OS << "enable";
  else if (state == Full)
    OS << "full";
  else if (state == AssumeSafety)
    OS << "assume_safety";
  else
    OS << "disable";
  OS << ")";
  return ValueName;
}

// Return a string suitable for identifying this attribute in diagnostics.
std::string
LoopHintAttr::getDiagnosticName(const PrintingPolicy &Policy) const {
  unsigned SpellingIndex = getAttributeSpellingListIndex();
  if (SpellingIndex == Pragma_nounroll)
    return "#pragma nounroll";
  else if (SpellingIndex == Pragma_unroll)
    return "#pragma unroll" +
           (option == UnrollCount ? getValueString(Policy) : "");
  else if (SpellingIndex == Pragma_nounroll_and_jam)
    return "#pragma nounroll_and_jam";
  else if (SpellingIndex == Pragma_unroll_and_jam)
    return "#pragma unroll_and_jam" +
           (option == UnrollAndJamCount ? getValueString(Policy) : "");

  assert(SpellingIndex == Pragma_clang_loop && "Unexpected spelling");
  return getOptionName(option) + getValueString(Policy);
}

void OMPDeclareSimdDeclAttr::printPrettyPragma(
    raw_ostream &OS, const PrintingPolicy &Policy) const {
  if (getBranchState() != BS_Undefined)
    OS << ' ' << ConvertBranchStateTyToStr(getBranchState());
  if (auto *E = getSimdlen()) {
    OS << " simdlen(";
    E->printPretty(OS, nullptr, Policy);
    OS << ")";
  }
  if (uniforms_size() > 0) {
    OS << " uniform";
    StringRef Sep = "(";
    for (auto *E : uniforms()) {
      OS << Sep;
      E->printPretty(OS, nullptr, Policy);
      Sep = ", ";
    }
    OS << ")";
  }
  alignments_iterator NI = alignments_begin();
  for (auto *E : aligneds()) {
    OS << " aligned(";
    E->printPretty(OS, nullptr, Policy);
    if (*NI) {
      OS << ": ";
      (*NI)->printPretty(OS, nullptr, Policy);
    }
    OS << ")";
    ++NI;
  }
  steps_iterator I = steps_begin();
  modifiers_iterator MI = modifiers_begin();
  for (auto *E : linears()) {
    OS << " linear(";
    if (*MI != OMPC_LINEAR_unknown)
      OS << getOpenMPSimpleClauseTypeName(llvm::omp::Clause::OMPC_linear, *MI)
         << "(";
    E->printPretty(OS, nullptr, Policy);
    if (*MI != OMPC_LINEAR_unknown)
      OS << ")";
    if (*I) {
      OS << ": ";
      (*I)->printPretty(OS, nullptr, Policy);
    }
    OS << ")";
    ++I;
    ++MI;
  }
}

void OMPDeclareTargetDeclAttr::printPrettyPragma(
    raw_ostream &OS, const PrintingPolicy &Policy) const {
  // Use fake syntax because it is for testing and debugging purpose only.
  if (getDevType() != DT_Any)
    OS << " device_type(" << ConvertDevTypeTyToStr(getDevType()) << ")";
  if (getMapType() != MT_To && getMapType() != MT_Enter)
    OS << ' ' << ConvertMapTypeTyToStr(getMapType());
  if (Expr *E = getIndirectExpr()) {
    OS << " indirect(";
    E->printPretty(OS, nullptr, Policy);
    OS << ")";
  } else if (getIndirect()) {
    OS << " indirect";
  }
}

std::optional<OMPDeclareTargetDeclAttr *>
OMPDeclareTargetDeclAttr::getActiveAttr(const ValueDecl *VD) {
  if (llvm::all_of(VD->redecls(), [](const Decl *D) { return !D->hasAttrs(); }))
    return std::nullopt;
  unsigned Level = 0;
  OMPDeclareTargetDeclAttr *FoundAttr = nullptr;
  for (const Decl *D : VD->redecls()) {
    for (auto *Attr : D->specific_attrs<OMPDeclareTargetDeclAttr>()) {
      if (Level <= Attr->getLevel()) {
        Level = Attr->getLevel();
        FoundAttr = Attr;
      }
    }
  }
  if (FoundAttr)
    return FoundAttr;
  return std::nullopt;
}

std::optional<OMPDeclareTargetDeclAttr::MapTypeTy>
OMPDeclareTargetDeclAttr::isDeclareTargetDeclaration(const ValueDecl *VD) {
  std::optional<OMPDeclareTargetDeclAttr *> ActiveAttr = getActiveAttr(VD);
  if (ActiveAttr)
    return (*ActiveAttr)->getMapType();
  return std::nullopt;
}

std::optional<OMPDeclareTargetDeclAttr::DevTypeTy>
OMPDeclareTargetDeclAttr::getDeviceType(const ValueDecl *VD) {
  std::optional<OMPDeclareTargetDeclAttr *> ActiveAttr = getActiveAttr(VD);
  if (ActiveAttr)
    return (*ActiveAttr)->getDevType();
  return std::nullopt;
}

std::optional<SourceLocation>
OMPDeclareTargetDeclAttr::getLocation(const ValueDecl *VD) {
  std::optional<OMPDeclareTargetDeclAttr *> ActiveAttr = getActiveAttr(VD);
  if (ActiveAttr)
    return (*ActiveAttr)->getRange().getBegin();
  return std::nullopt;
}

namespace clang {
llvm::raw_ostream &operator<<(llvm::raw_ostream &OS, const OMPTraitInfo &TI);
llvm::raw_ostream &operator<<(llvm::raw_ostream &OS, const OMPTraitInfo *TI);
}

void OMPDeclareVariantAttr::printPrettyPragma(
    raw_ostream &OS, const PrintingPolicy &Policy) const {
  if (const Expr *E = getVariantFuncRef()) {
    OS << "(";
    E->printPretty(OS, nullptr, Policy);
    OS << ")";
  }
  OS << " match(" << traitInfos << ")";

  auto PrintExprs = [&OS, &Policy](Expr **Begin, Expr **End) {
    for (Expr **I = Begin; I != End; ++I) {
      assert(*I && "Expected non-null Stmt");
      if (I != Begin)
        OS << ",";
      (*I)->printPretty(OS, nullptr, Policy);
    }
  };
  if (adjustArgsNothing_size()) {
    OS << " adjust_args(nothing:";
    PrintExprs(adjustArgsNothing_begin(), adjustArgsNothing_end());
    OS << ")";
  }
  if (adjustArgsNeedDevicePtr_size()) {
    OS << " adjust_args(need_device_ptr:";
    PrintExprs(adjustArgsNeedDevicePtr_begin(), adjustArgsNeedDevicePtr_end());
    OS << ")";
  }
  if (adjustArgsNeedDeviceAddr_size()) {
    OS << " adjust_args(need_device_addr:";
    PrintExprs(adjustArgsNeedDeviceAddr_begin(),
               adjustArgsNeedDeviceAddr_end());
    OS << ")";
  }

  auto PrintInteropInfo = [&OS](OMPInteropInfo *Begin, OMPInteropInfo *End) {
    for (OMPInteropInfo *I = Begin; I != End; ++I) {
      if (I != Begin)
        OS << ", ";
      OS << "interop(";
      OS << getInteropTypeString(I);
      OS << ")";
    }
  };
  if (appendArgs_size()) {
    OS << " append_args(";
    PrintInteropInfo(appendArgs_begin(), appendArgs_end());
    OS << ")";
  }
}

unsigned AlignedAttr::getAlignment(ASTContext &Ctx) const {
  assert(!isAlignmentDependent());
  if (getCachedAlignmentValue())
    return *getCachedAlignmentValue();

  // Handle alignmentType case.
  if (!isAlignmentExpr()) {
    QualType T = getAlignmentType()->getType();

    // C++ [expr.alignof]p3:
    //     When alignof is applied to a reference type, the result is the
    //     alignment of the referenced type.
    T = T.getNonReferenceType();

    if (T.getQualifiers().hasUnaligned())
      return Ctx.getCharWidth();

    return Ctx.getTypeAlignInChars(T.getTypePtr()).getQuantity() *
           Ctx.getCharWidth();
  }

  // Handle alignmentExpr case.
  if (alignmentExpr)
    return alignmentExpr->EvaluateKnownConstInt(Ctx).getZExtValue() *
           Ctx.getCharWidth();

  return Ctx.getTargetDefaultAlignForAttributeAligned();
}

StringLiteral *FormatMatchesAttr::getFormatString() const {
  return cast<StringLiteral>(getExpectedFormat());
}

namespace {
// Arguments whose types fail this test never compare equal unless there's a
// specialization of equalAttrArgs for the type. Specilization for the following
// arguments haven't been implemented yet:
//  - DeclArgument
//  - OMPTraitInfoArgument
//  - VariadicOMPInteropInfoArgument
#define USE_DEFAULT_EQUALITY                                                   \
  (std::is_same_v<T, StringRef> || std::is_same_v<T, VersionTuple> ||          \
   std::is_same_v<T, IdentifierInfo *> || std::is_same_v<T, char *> ||         \
   std::is_enum_v<T> || std::is_integral_v<T>)

template <class T>
typename std::enable_if_t<!USE_DEFAULT_EQUALITY, bool>
equalAttrArgs(T A, T B, StructuralEquivalenceContext &Context) {
  return false;
}

template <class T>
typename std::enable_if_t<USE_DEFAULT_EQUALITY, bool>
equalAttrArgs(T A1, T A2, StructuralEquivalenceContext &Context) {
  return A1 == A2;
}

template <>
bool equalAttrArgs<ParamIdx>(ParamIdx P1, ParamIdx P2,
                             StructuralEquivalenceContext &) {
  // ParamIdx can be invalid when representing an optional parameter that was
  // not specified (e.g. the second argument of alloc_size(N)).
  // ParamIdx::operator== asserts both sides are valid, so guard against the
  // invalid case before delegating to it.
  if (P1.isValid() != P2.isValid())
    return false;
  if (!P1.isValid())
    return true;
  return P1 == P2;
}

template <class T>
bool equalAttrArgs(T *A1_B, T *A1_E, T *A2_B, T *A2_E,
                   StructuralEquivalenceContext &Context) {
  if (A1_E - A1_B != A2_E - A2_B)
    return false;

  for (; A1_B != A1_E; ++A1_B, ++A2_B)
    if (!equalAttrArgs(*A1_B, *A2_B, Context))
      return false;

  return true;
}

template <>
bool equalAttrArgs<Attr *>(Attr *A1, Attr *A2,
                           StructuralEquivalenceContext &Context) {
  if (!A1 || !A2)
    return A1 == A2;
  return A1->isEquivalent(*A2, Context);
}

template <>
bool equalAttrArgs<Expr *>(Expr *A1, Expr *A2,
                           StructuralEquivalenceContext &Context) {
  return ASTStructuralEquivalence::isEquivalent(Context, A1, A2);
}

template <>
bool equalAttrArgs<QualType>(QualType T1, QualType T2,
                             StructuralEquivalenceContext &Context) {
  return ASTStructuralEquivalence::isEquivalent(Context, T1, T2);
}

template <>
bool equalAttrArgs<const IdentifierInfo *>(
    const IdentifierInfo *Name1, const IdentifierInfo *Name2,
    StructuralEquivalenceContext &Context) {
  return ASTStructuralEquivalence::isEquivalent(Name1, Name2);
}

bool areAlignedAttrsEqual(const AlignedAttr &A1, const AlignedAttr &A2,
                          StructuralEquivalenceContext &Context) {
  if (A1.getSpelling() != A2.getSpelling())
    return false;

  if (A1.isAlignmentExpr() != A2.isAlignmentExpr())
    return false;

  if (A1.isAlignmentExpr())
    return equalAttrArgs(A1.getAlignmentExpr(), A2.getAlignmentExpr(), Context);

  return equalAttrArgs(A1.getAlignmentType()->getType(),
                       A2.getAlignmentType()->getType(), Context);
}
} // namespace

namespace {
// Machinery to unique attributes based on the arguments.
// The construction mirrors the equivalent testing code above.
// The content of the arguments are added to the FoldingSetNodeID instance,
// which allows the AttributedTypes to unique the attributes based on
// the value of the arguments.

#define USE_DEFAULT_PROFILE                                                    \
  (std::is_same_v<T, StringRef> || std::is_same_v<T, VersionTuple> ||          \
   std::is_same_v<T, IdentifierInfo *> ||                                      \
   std::is_same_v<T, const IdentifierInfo *> || std::is_enum_v<T> ||           \
   std::is_integral_v<T>)

template <class T>
typename std::enable_if_t<!USE_DEFAULT_PROFILE>
profileAttrArg(llvm::FoldingSetNodeID &, const ASTContext &, T) {
  llvm_unreachable("profile not implemented for this type");
}

template <class T>
typename std::enable_if_t<USE_DEFAULT_PROFILE>
profileAttrArg(llvm::FoldingSetNodeID &ID, const ASTContext &, T V) {
  if constexpr (std::is_same_v<T, StringRef>)
    ID.AddString(V);
  else if constexpr (std::is_same_v<T, VersionTuple>) {
    ID.AddInteger(V.getMajor());
    ID.AddInteger(V.getMinor().value_or(0));
    ID.AddInteger(V.getSubminor().value_or(0));
    ID.AddInteger(V.getBuild().value_or(0));
  } else if constexpr (std::is_same_v<T, IdentifierInfo *> ||
                       std::is_same_v<T, const IdentifierInfo *>)
    ID.AddPointer(V);
  else
    ID.AddInteger(static_cast<long long>(V));
}

template <>
inline void profileAttrArg<ParamIdx>(llvm::FoldingSetNodeID &ID,
                                     const ASTContext &, ParamIdx P) {
  ID.AddBoolean(P.isValid());
  if (P.isValid())
    ID.AddInteger(P.getASTIndex());
}

template <class T>
inline void profileAttrArg(llvm::FoldingSetNodeID &ID, const ASTContext &Ctx,
                           T *Begin, T *End) {
  ID.AddInteger(End - Begin);
  for (; Begin != End; ++Begin)
    profileAttrArg(ID, Ctx, *Begin);
}

template <>
inline void profileAttrArg<Attr *>(llvm::FoldingSetNodeID &ID,
                                   const ASTContext &Ctx, Attr *A) {
  if (!A) {
    ID.AddPointer(nullptr);
    return;
  }
  ID.AddInteger(A->getKind());
  A->Profile(ID, Ctx);
}

template <>
inline void profileAttrArg<Expr *>(llvm::FoldingSetNodeID &ID,
                                   const ASTContext &Ctx, Expr *E) {
  E->Profile(ID, Ctx, /*Canonical=*/true);
}

template <>
inline void profileAttrArg<QualType>(llvm::FoldingSetNodeID &ID,
                                     const ASTContext &, QualType T) {
  ID.AddPointer(T.getCanonicalType().getAsOpaquePtr());
}

void profileAlignedAttr(const AlignedAttr &A, llvm::FoldingSetNodeID &ID,
                        const ASTContext &Ctx) {
  ID.AddInteger(A.getSpellingListIndex());
  ID.AddBoolean(A.isAlignmentExpr());
  if (A.isAlignmentExpr())
    profileAttrArg(ID, Ctx, A.getAlignmentExpr());
  else
    profileAttrArg(ID, Ctx, A.getAlignmentType()->getType());
}
} // namespace

#include "clang/AST/AttrImpl.inc"
