clang/lib/AST/AttrImpl.cpp

   1 //===--- AttrImpl.cpp - Classes for representing attributes -----*- 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 out-of-line methods for Attr classes.
  10 //
  11 //===----------------------------------------------------------------------===//
  12
  13 #include "clang/AST/ASTContext.h"
  14 #include "clang/AST/Attr.h"
  15 #include "clang/AST/Expr.h"
  16 #include "clang/AST/Type.h"
  17 using namespace clang;
  18
  19 void LoopHintAttr::printPrettyPragma(raw_ostream &OS,
  20                                      const PrintingPolicy &Policy) const {
  21   unsigned SpellingIndex = getAttributeSpellingListIndex();
  22   // For "#pragma unroll" and "#pragma nounroll" the string "unroll" or
  23   // "nounroll" is already emitted as the pragma name.
  24   if (SpellingIndex == Pragma_nounroll ||
  25       SpellingIndex == Pragma_nounroll_and_jam)
  26     return;
  27   else if (SpellingIndex == Pragma_unroll ||
  28            SpellingIndex == Pragma_unroll_and_jam) {
  29     OS << ' ' << getValueString(Policy);
  30     return;
  31   }
  32
  33   assert(SpellingIndex == Pragma_clang_loop && "Unexpected spelling");
  34   OS << ' ' << getOptionName(option) << getValueString(Policy);
  35 }
  36
  37 // Return a string containing the loop hint argument including the
  38 // enclosing parentheses.
  39 std::string LoopHintAttr::getValueString(const PrintingPolicy &Policy) const {
  40   std::string ValueName;
  41   llvm::raw_string_ostream OS(ValueName);
  42   OS << "(";
  43   if (state == Numeric)
  44     value->printPretty(OS, nullptr, Policy);
  45   else if (state == FixedWidth || state == ScalableWidth) {
  46     if (value) {
  47       value->printPretty(OS, nullptr, Policy);
  48       if (state == ScalableWidth)
  49         OS << ", scalable";
  50     } else if (state == ScalableWidth)
  51       OS << "scalable";
  52     else
  53       OS << "fixed";
  54   } else if (state == Enable)
  55     OS << "enable";
  56   else if (state == Full)
  57     OS << "full";
  58   else if (state == AssumeSafety)
  59     OS << "assume_safety";
  60   else
  61     OS << "disable";
  62   OS << ")";
  63   return ValueName;
  64 }
  65
  66 // Return a string suitable for identifying this attribute in diagnostics.
  67 std::string
  68 LoopHintAttr::getDiagnosticName(const PrintingPolicy &Policy) const {
  69   unsigned SpellingIndex = getAttributeSpellingListIndex();
  70   if (SpellingIndex == Pragma_nounroll)
  71     return "#pragma nounroll";
  72   else if (SpellingIndex == Pragma_unroll)
  73     return "#pragma unroll" +
  74            (option == UnrollCount ? getValueString(Policy) : "");
  75   else if (SpellingIndex == Pragma_nounroll_and_jam)
  76     return "#pragma nounroll_and_jam";
  77   else if (SpellingIndex == Pragma_unroll_and_jam)
  78     return "#pragma unroll_and_jam" +
  79            (option == UnrollAndJamCount ? getValueString(Policy) : "");
  80
  81   assert(SpellingIndex == Pragma_clang_loop && "Unexpected spelling");
  82   return getOptionName(option) + getValueString(Policy);
  83 }
  84
  85 void OMPDeclareSimdDeclAttr::printPrettyPragma(
  86     raw_ostream &OS, const PrintingPolicy &Policy) const {
  87   if (getBranchState() != BS_Undefined)
  88     OS << ' ' << ConvertBranchStateTyToStr(getBranchState());
  89   if (auto *E = getSimdlen()) {
  90     OS << " simdlen(";
  91     E->printPretty(OS, nullptr, Policy);
  92     OS << ")";
  93   }
  94   if (uniforms_size() > 0) {
  95     OS << " uniform";
  96     StringRef Sep = "(";
  97     for (auto *E : uniforms()) {
  98       OS << Sep;
  99       E->printPretty(OS, nullptr, Policy);
 100       Sep = ", ";
 101     }
 102     OS << ")";
 103   }
 104   alignments_iterator NI = alignments_begin();
 105   for (auto *E : aligneds()) {
 106     OS << " aligned(";
 107     E->printPretty(OS, nullptr, Policy);
 108     if (*NI) {
 109       OS << ": ";
 110       (*NI)->printPretty(OS, nullptr, Policy);
 111     }
 112     OS << ")";
 113     ++NI;
 114   }
 115   steps_iterator I = steps_begin();
 116   modifiers_iterator MI = modifiers_begin();
 117   for (auto *E : linears()) {
 118     OS << " linear(";
 119     if (*MI != OMPC_LINEAR_unknown)
 120       OS << getOpenMPSimpleClauseTypeName(llvm::omp::Clause::OMPC_linear, *MI)
 121          << "(";
 122     E->printPretty(OS, nullptr, Policy);
 123     if (*MI != OMPC_LINEAR_unknown)
 124       OS << ")";
 125     if (*I) {
 126       OS << ": ";
 127       (*I)->printPretty(OS, nullptr, Policy);
 128     }
 129     OS << ")";
 130     ++I;
 131     ++MI;
 132   }
 133 }
 134
 135 void OMPDeclareTargetDeclAttr::printPrettyPragma(
 136     raw_ostream &OS, const PrintingPolicy &Policy) const {
 137   // Use fake syntax because it is for testing and debugging purpose only.
 138   if (getDevType() != DT_Any)
 139     OS << " device_type(" << ConvertDevTypeTyToStr(getDevType()) << ")";
 140   if (getMapType() != MT_To)
 141     OS << ' ' << ConvertMapTypeTyToStr(getMapType());
 142   if (Expr *E = getIndirectExpr()) {
 143     OS << " indirect(";
 144     E->printPretty(OS, nullptr, Policy);
 145     OS << ")";
 146   } else if (getIndirect()) {
 147     OS << " indirect";
 148   }
 149 }
 150
 151 llvm::Optional<OMPDeclareTargetDeclAttr *>
 152 OMPDeclareTargetDeclAttr::getActiveAttr(const ValueDecl *VD) {
 153   if (!VD->hasAttrs())
 154     return llvm::None;
 155   unsigned Level = 0;
 156   OMPDeclareTargetDeclAttr *FoundAttr = nullptr;
 157   for (auto *Attr : VD->specific_attrs<OMPDeclareTargetDeclAttr>()) {
 158     if (Level <= Attr->getLevel()) {
 159       Level = Attr->getLevel();
 160       FoundAttr = Attr;
 161     }
 162   }
 163   if (FoundAttr)
 164     return FoundAttr;
 165   return llvm::None;
 166 }
 167
 168 llvm::Optional<OMPDeclareTargetDeclAttr::MapTypeTy>
 169 OMPDeclareTargetDeclAttr::isDeclareTargetDeclaration(const ValueDecl *VD) {
 170   llvm::Optional<OMPDeclareTargetDeclAttr *> ActiveAttr = getActiveAttr(VD);
 171   if (ActiveAttr)
 172     return ActiveAttr.value()->getMapType();
 173   return llvm::None;
 174 }
 175
 176 llvm::Optional<OMPDeclareTargetDeclAttr::DevTypeTy>
 177 OMPDeclareTargetDeclAttr::getDeviceType(const ValueDecl *VD) {
 178   llvm::Optional<OMPDeclareTargetDeclAttr *> ActiveAttr = getActiveAttr(VD);
 179   if (ActiveAttr)
 180     return ActiveAttr.value()->getDevType();
 181   return llvm::None;
 182 }
 183
 184 llvm::Optional<SourceLocation>
 185 OMPDeclareTargetDeclAttr::getLocation(const ValueDecl *VD) {
 186   llvm::Optional<OMPDeclareTargetDeclAttr *> ActiveAttr = getActiveAttr(VD);
 187   if (ActiveAttr)
 188     return ActiveAttr.value()->getRange().getBegin();
 189   return llvm::None;
 190 }
 191
 192 namespace clang {
 193 llvm::raw_ostream &operator<<(llvm::raw_ostream &OS, const OMPTraitInfo &TI);
 194 llvm::raw_ostream &operator<<(llvm::raw_ostream &OS, const OMPTraitInfo *TI);
 195 }
 196
 197 void OMPDeclareVariantAttr::printPrettyPragma(
 198     raw_ostream &OS, const PrintingPolicy &Policy) const {
 199   if (const Expr *E = getVariantFuncRef()) {
 200     OS << "(";
 201     E->printPretty(OS, nullptr, Policy);
 202     OS << ")";
 203   }
 204   OS << " match(" << traitInfos << ")";
 205
 206   auto PrintExprs = [&OS, &Policy](Expr **Begin, Expr **End) {
 207     for (Expr **I = Begin; I != End; ++I) {
 208       assert(*I && "Expected non-null Stmt");
 209       if (I != Begin)
 210         OS << ",";
 211       (*I)->printPretty(OS, nullptr, Policy);
 212     }
 213   };
 214   if (adjustArgsNothing_size()) {
 215     OS << " adjust_args(nothing:";
 216     PrintExprs(adjustArgsNothing_begin(), adjustArgsNothing_end());
 217     OS << ")";
 218   }
 219   if (adjustArgsNeedDevicePtr_size()) {
 220     OS << " adjust_args(need_device_ptr:";
 221     PrintExprs(adjustArgsNeedDevicePtr_begin(), adjustArgsNeedDevicePtr_end());
 222     OS << ")";
 223   }
 224
 225   auto PrintInteropInfo = [&OS](OMPInteropInfo *Begin, OMPInteropInfo *End) {
 226     for (OMPInteropInfo *I = Begin; I != End; ++I) {
 227       if (I != Begin)
 228         OS << ", ";
 229       OS << "interop(";
 230       OS << getInteropTypeString(I);
 231       OS << ")";
 232     }
 233   };
 234   if (appendArgs_size()) {
 235     OS << " append_args(";
 236     PrintInteropInfo(appendArgs_begin(), appendArgs_end());
 237     OS << ")";
 238   }
 239 }
 240
 241 #include "clang/AST/AttrImpl.inc"