contrib/llvm/tools/clang/lib/Basic/Targets/Hexagon.cpp

   1 //===--- Hexagon.cpp - Implement Hexagon target feature support -----------===//
   2 //
   3 //                     The LLVM Compiler Infrastructure
   4 //
   5 // This file is distributed under the University of Illinois Open Source
   6 // License. See LICENSE.TXT for details.
   7 //
   8 //===----------------------------------------------------------------------===//
   9 //
  10 // This file implements Hexagon TargetInfo objects.
  11 //
  12 //===----------------------------------------------------------------------===//
  13
  14 #include "Hexagon.h"
  15 #include "Targets.h"
  16 #include "clang/Basic/MacroBuilder.h"
  17 #include "clang/Basic/TargetBuiltins.h"
  18 #include "llvm/ADT/StringSwitch.h"
  19
  20 using namespace clang;
  21 using namespace clang::targets;
  22
  23 void HexagonTargetInfo::getTargetDefines(const LangOptions &Opts,
  24                                          MacroBuilder &Builder) const {
  25   Builder.defineMacro("__qdsp6__", "1");
  26   Builder.defineMacro("__hexagon__", "1");
  27
  28   if (CPU == "hexagonv4") {
  29     Builder.defineMacro("__HEXAGON_V4__");
  30     Builder.defineMacro("__HEXAGON_ARCH__", "4");
  31     if (Opts.HexagonQdsp6Compat) {
  32       Builder.defineMacro("__QDSP6_V4__");
  33       Builder.defineMacro("__QDSP6_ARCH__", "4");
  34     }
  35   } else if (CPU == "hexagonv5") {
  36     Builder.defineMacro("__HEXAGON_V5__");
  37     Builder.defineMacro("__HEXAGON_ARCH__", "5");
  38     if (Opts.HexagonQdsp6Compat) {
  39       Builder.defineMacro("__QDSP6_V5__");
  40       Builder.defineMacro("__QDSP6_ARCH__", "5");
  41     }
  42   } else if (CPU == "hexagonv55") {
  43     Builder.defineMacro("__HEXAGON_V55__");
  44     Builder.defineMacro("__HEXAGON_ARCH__", "55");
  45     Builder.defineMacro("__QDSP6_V55__");
  46     Builder.defineMacro("__QDSP6_ARCH__", "55");
  47   } else if (CPU == "hexagonv60") {
  48     Builder.defineMacro("__HEXAGON_V60__");
  49     Builder.defineMacro("__HEXAGON_ARCH__", "60");
  50     Builder.defineMacro("__QDSP6_V60__");
  51     Builder.defineMacro("__QDSP6_ARCH__", "60");
  52   } else if (CPU == "hexagonv62") {
  53     Builder.defineMacro("__HEXAGON_V62__");
  54     Builder.defineMacro("__HEXAGON_ARCH__", "62");
  55   } else if (CPU == "hexagonv65") {
  56     Builder.defineMacro("__HEXAGON_V65__");
  57     Builder.defineMacro("__HEXAGON_ARCH__", "65");
  58   }
  59
  60   if (hasFeature("hvx-length64b")) {
  61     Builder.defineMacro("__HVX__");
  62     Builder.defineMacro("__HVX_ARCH__", HVXVersion);
  63     Builder.defineMacro("__HVX_LENGTH__", "64");
  64   }
  65
  66   if (hasFeature("hvx-length128b")) {
  67     Builder.defineMacro("__HVX__");
  68     Builder.defineMacro("__HVX_ARCH__", HVXVersion);
  69     Builder.defineMacro("__HVX_LENGTH__", "128");
  70     // FIXME: This macro is deprecated.
  71     Builder.defineMacro("__HVXDBL__");
  72   }
  73 }
  74
  75 bool HexagonTargetInfo::initFeatureMap(
  76     llvm::StringMap<bool> &Features, DiagnosticsEngine &Diags, StringRef CPU,
  77     const std::vector<std::string> &FeaturesVec) const {
  78   Features["hvx-double"] = false;
  79   Features["long-calls"] = false;
  80
  81   return TargetInfo::initFeatureMap(Features, Diags, CPU, FeaturesVec);
  82 }
  83
  84 bool HexagonTargetInfo::handleTargetFeatures(std::vector<std::string> &Features,
  85                                              DiagnosticsEngine &Diags) {
  86   for (auto &F : Features) {
  87     if (F == "+hvx-length64b")
  88       HasHVX = HasHVX64B = true;
  89     else if (F == "+hvx-length128b")
  90       HasHVX = HasHVX128B = true;
  91     else if (F.find("+hvxv") != std::string::npos) {
  92       HasHVX = true;
  93       HVXVersion = F.substr(std::string("+hvxv").length());
  94     } else if (F == "-hvx")
  95       HasHVX = HasHVX64B = HasHVX128B = false;
  96     else if (F == "+long-calls")
  97       UseLongCalls = true;
  98     else if (F == "-long-calls")
  99       UseLongCalls = false;
 100   }
 101   return true;
 102 }
 103
 104 const char *const HexagonTargetInfo::GCCRegNames[] = {
 105     "r0",  "r1",  "r2",  "r3",  "r4",  "r5",  "r6",  "r7",  "r8",
 106     "r9",  "r10", "r11", "r12", "r13", "r14", "r15", "r16", "r17",
 107     "r18", "r19", "r20", "r21", "r22", "r23", "r24", "r25", "r26",
 108     "r27", "r28", "r29", "r30", "r31", "p0",  "p1",  "p2",  "p3",
 109     "sa0", "lc0", "sa1", "lc1", "m0",  "m1",  "usr", "ugp"
 110 };
 111
 112 ArrayRef<const char *> HexagonTargetInfo::getGCCRegNames() const {
 113   return llvm::makeArrayRef(GCCRegNames);
 114 }
 115
 116 const TargetInfo::GCCRegAlias HexagonTargetInfo::GCCRegAliases[] = {
 117     {{"sp"}, "r29"},
 118     {{"fp"}, "r30"},
 119     {{"lr"}, "r31"},
 120 };
 121
 122 ArrayRef<TargetInfo::GCCRegAlias> HexagonTargetInfo::getGCCRegAliases() const {
 123   return llvm::makeArrayRef(GCCRegAliases);
 124 }
 125
 126 const Builtin::Info HexagonTargetInfo::BuiltinInfo[] = {
 127 #define BUILTIN(ID, TYPE, ATTRS)                                               \
 128   {#ID, TYPE, ATTRS, nullptr, ALL_LANGUAGES, nullptr},
 129 #define LIBBUILTIN(ID, TYPE, ATTRS, HEADER)                                    \
 130   {#ID, TYPE, ATTRS, HEADER, ALL_LANGUAGES, nullptr},
 131 #include "clang/Basic/BuiltinsHexagon.def"
 132 };
 133
 134 bool HexagonTargetInfo::hasFeature(StringRef Feature) const {
 135   return llvm::StringSwitch<bool>(Feature)
 136       .Case("hexagon", true)
 137       .Case("hvx", HasHVX)
 138       .Case("hvx-length64b", HasHVX64B)
 139       .Case("hvx-length128b", HasHVX128B)
 140       .Case("long-calls", UseLongCalls)
 141       .Default(false);
 142 }
 143
 144 const char *HexagonTargetInfo::getHexagonCPUSuffix(StringRef Name) {
 145   return llvm::StringSwitch<const char *>(Name)
 146       .Case("hexagonv4", "4")
 147       .Case("hexagonv5", "5")
 148       .Case("hexagonv55", "55")
 149       .Case("hexagonv60", "60")
 150       .Case("hexagonv62", "62")
 151       .Case("hexagonv65", "65")
 152       .Default(nullptr);
 153 }
 154
 155 ArrayRef<Builtin::Info> HexagonTargetInfo::getTargetBuiltins() const {
 156   return llvm::makeArrayRef(BuiltinInfo, clang::Hexagon::LastTSBuiltin -
 157                                              Builtin::FirstTSBuiltin);
 158 }