clang/lib/Basic/Targets/CSKY.cpp

   1 //===--- CSKY.cpp - Implement CSKY target feature support -----------------===//
   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 implements CSKY TargetInfo objects.
  10 //
  11 //===----------------------------------------------------------------------===//
  12
  13 #include "CSKY.h"
  14
  15 using namespace clang;
  16 using namespace clang::targets;
  17
  18 bool CSKYTargetInfo::isValidCPUName(StringRef Name) const {
  19   return llvm::CSKY::parseCPUArch(Name) != llvm::CSKY::ArchKind::INVALID;
  20 }
  21
  22 bool CSKYTargetInfo::setCPU(const std::string &Name) {
  23   llvm::CSKY::ArchKind archKind = llvm::CSKY::parseCPUArch(Name);
  24   bool isValid = (archKind != llvm::CSKY::ArchKind::INVALID);
  25
  26   if (isValid) {
  27     CPU = Name;
  28     Arch = archKind;
  29   }
  30
  31   return isValid;
  32 }
  33
  34 void CSKYTargetInfo::getTargetDefines(const LangOptions &Opts,
  35                                       MacroBuilder &Builder) const {
  36   Builder.defineMacro("__csky__", "2");
  37   Builder.defineMacro("__CSKY__", "2");
  38   Builder.defineMacro("__ckcore__", "2");
  39   Builder.defineMacro("__CKCORE__", "2");
  40
  41   Builder.defineMacro("__CSKYABI__", ABI == "abiv2" ? "2" : "1");
  42   Builder.defineMacro("__cskyabi__", ABI == "abiv2" ? "2" : "1");
  43
  44   StringRef ArchName = "ck810";
  45   StringRef CPUName = "ck810";
  46
  47   if (Arch != llvm::CSKY::ArchKind::INVALID) {
  48     ArchName = llvm::CSKY::getArchName(Arch);
  49     CPUName = CPU;
  50   }
  51
  52   Builder.defineMacro("__" + ArchName.upper() + "__");
  53   Builder.defineMacro("__" + ArchName.lower() + "__");
  54   if (ArchName != CPUName) {
  55     Builder.defineMacro("__" + CPUName.upper() + "__");
  56     Builder.defineMacro("__" + CPUName.lower() + "__");
  57   }
  58
  59   // TODO: Add support for BE if BE was supported later
  60   StringRef endian = "__cskyLE__";
  61
  62   Builder.defineMacro(endian);
  63   Builder.defineMacro(endian.upper());
  64   Builder.defineMacro(endian.lower());
  65
  66   if (DSPV2) {
  67     StringRef dspv2 = "__CSKY_DSPV2__";
  68     Builder.defineMacro(dspv2);
  69     Builder.defineMacro(dspv2.lower());
  70   }
  71
  72   if (VDSPV2) {
  73     StringRef vdspv2 = "__CSKY_VDSPV2__";
  74     Builder.defineMacro(vdspv2);
  75     Builder.defineMacro(vdspv2.lower());
  76
  77     if (HardFloat) {
  78       StringRef vdspv2_f = "__CSKY_VDSPV2_F__";
  79       Builder.defineMacro(vdspv2_f);
  80       Builder.defineMacro(vdspv2_f.lower());
  81     }
  82   }
  83   if (VDSPV1) {
  84     StringRef vdspv1_64 = "__CSKY_VDSP64__";
  85     StringRef vdspv1_128 = "__CSKY_VDSP128__";
  86
  87     Builder.defineMacro(vdspv1_64);
  88     Builder.defineMacro(vdspv1_64.lower());
  89     Builder.defineMacro(vdspv1_128);
  90     Builder.defineMacro(vdspv1_128.lower());
  91   }
  92   if (is3E3R1) {
  93     StringRef is3e3r1 = "__CSKY_3E3R1__";
  94     Builder.defineMacro(is3e3r1);
  95     Builder.defineMacro(is3e3r1.lower());
  96   }
  97 }
  98
  99 bool CSKYTargetInfo::hasFeature(StringRef Feature) const {
 100   return llvm::StringSwitch<bool>(Feature)
 101       .Case("hard-float", HardFloat)
 102       .Case("hard-float-abi", HardFloatABI)
 103       .Case("fpuv2_sf", FPUV2_SF)
 104       .Case("fpuv2_df", FPUV2_DF)
 105       .Case("fpuv3_sf", FPUV3_SF)
 106       .Case("fpuv3_df", FPUV3_DF)
 107       .Case("vdspv2", VDSPV2)
 108       .Case("dspv2", DSPV2)
 109       .Case("vdspv1", VDSPV1)
 110       .Case("3e3r1", is3E3R1)
 111       .Default(false);
 112 }
 113
 114 bool CSKYTargetInfo::handleTargetFeatures(std::vector<std::string> &Features,
 115                                           DiagnosticsEngine &Diags) {
 116   for (const auto &Feature : Features) {
 117     if (Feature == "+hard-float")
 118       HardFloat = true;
 119     if (Feature == "+hard-float-abi")
 120       HardFloatABI = true;
 121     if (Feature == "+fpuv2_sf")
 122       FPUV2_SF = true;
 123     if (Feature == "+fpuv2_df")
 124       FPUV2_DF = true;
 125     if (Feature == "+fpuv3_sf")
 126       FPUV3_SF = true;
 127     if (Feature == "+fpuv3_df")
 128       FPUV3_DF = true;
 129     if (Feature == "+vdspv2")
 130       VDSPV2 = true;
 131     if (Feature == "+dspv2")
 132       DSPV2 = true;
 133     if (Feature == "+vdspv1")
 134       VDSPV1 = true;
 135     if (Feature == "+3e3r1")
 136       is3E3R1 = true;
 137   }
 138
 139   return true;
 140 }
 141
 142 ArrayRef<Builtin::Info> CSKYTargetInfo::getTargetBuiltins() const {
 143   return ArrayRef<Builtin::Info>();
 144 }
 145
 146 ArrayRef<const char *> CSKYTargetInfo::getGCCRegNames() const {
 147   static const char *const GCCRegNames[] = {
 148       // Integer registers
 149       "r0",
 150       "r1",
 151       "r2",
 152       "r3",
 153       "r4",
 154       "r5",
 155       "r6",
 156       "r7",
 157       "r8",
 158       "r9",
 159       "r10",
 160       "r11",
 161       "r12",
 162       "r13",
 163       "r14",
 164       "r15",
 165       "r16",
 166       "r17",
 167       "r18",
 168       "r19",
 169       "r20",
 170       "r21",
 171       "r22",
 172       "r23",
 173       "r24",
 174       "r25",
 175       "r26",
 176       "r27",
 177       "r28",
 178       "r29",
 179       "r30",
 180       "r31",
 181
 182       // Floating point registers
 183       "fr0",
 184       "fr1",
 185       "fr2",
 186       "fr3",
 187       "fr4",
 188       "fr5",
 189       "fr6",
 190       "fr7",
 191       "fr8",
 192       "fr9",
 193       "fr10",
 194       "fr11",
 195       "fr12",
 196       "fr13",
 197       "fr14",
 198       "fr15",
 199       "fr16",
 200       "fr17",
 201       "fr18",
 202       "fr19",
 203       "fr20",
 204       "fr21",
 205       "fr22",
 206       "fr23",
 207       "fr24",
 208       "fr25",
 209       "fr26",
 210       "fr27",
 211       "fr28",
 212       "fr29",
 213       "fr30",
 214       "fr31",
 215
 216   };
 217   return llvm::ArrayRef(GCCRegNames);
 218 }
 219
 220 ArrayRef<TargetInfo::GCCRegAlias> CSKYTargetInfo::getGCCRegAliases() const {
 221   static const TargetInfo::GCCRegAlias GCCRegAliases[] = {
 222       {{"a0"}, "r0"},
 223       {{"a1"}, "r1"},
 224       {{"a2"}, "r2"},
 225       {{"a3"}, "r3"},
 226       {{"l0"}, "r4"},
 227       {{"l1"}, "r5"},
 228       {{"l2"}, "r6"},
 229       {{"l3"}, "r7"},
 230       {{"l4"}, "r8"},
 231       {{"l5"}, "r9"},
 232       {{"l6"}, "r10"},
 233       {{"l7"}, "r11"},
 234       {{"t0"}, "r12"},
 235       {{"t1"}, "r13"},
 236       {{"sp"}, "r14"},
 237       {{"lr"}, "r15"},
 238       {{"l8"}, "r16"},
 239       {{"l9"}, "r17"},
 240       {{"t2"}, "r18"},
 241       {{"t3"}, "r19"},
 242       {{"t4"}, "r20"},
 243       {{"t5"}, "r21"},
 244       {{"t6"}, "r22"},
 245       {{"t7", "fp"}, "r23"},
 246       {{"t8", "top"}, "r24"},
 247       {{"t9", "bsp"}, "r25"},
 248       {{"r26"}, "r26"},
 249       {{"r27"}, "r27"},
 250       {{"gb", "rgb", "rdb"}, "r28"},
 251       {{"tb", "rtb"}, "r29"},
 252       {{"svbr"}, "r30"},
 253       {{"tls"}, "r31"},
 254
 255       {{"vr0"}, "fr0"},
 256       {{"vr1"}, "fr1"},
 257       {{"vr2"}, "fr2"},
 258       {{"vr3"}, "fr3"},
 259       {{"vr4"}, "fr4"},
 260       {{"vr5"}, "fr5"},
 261       {{"vr6"}, "fr6"},
 262       {{"vr7"}, "fr7"},
 263       {{"vr8"}, "fr8"},
 264       {{"vr9"}, "fr9"},
 265       {{"vr10"}, "fr10"},
 266       {{"vr11"}, "fr11"},
 267       {{"vr12"}, "fr12"},
 268       {{"vr13"}, "fr13"},
 269       {{"vr14"}, "fr14"},
 270       {{"vr15"}, "fr15"},
 271       {{"vr16"}, "fr16"},
 272       {{"vr17"}, "fr17"},
 273       {{"vr18"}, "fr18"},
 274       {{"vr19"}, "fr19"},
 275       {{"vr20"}, "fr20"},
 276       {{"vr21"}, "fr21"},
 277       {{"vr22"}, "fr22"},
 278       {{"vr23"}, "fr23"},
 279       {{"vr24"}, "fr24"},
 280       {{"vr25"}, "fr25"},
 281       {{"vr26"}, "fr26"},
 282       {{"vr27"}, "fr27"},
 283       {{"vr28"}, "fr28"},
 284       {{"vr29"}, "fr29"},
 285       {{"vr30"}, "fr30"},
 286       {{"vr31"}, "fr31"},
 287
 288   };
 289   return llvm::ArrayRef(GCCRegAliases);
 290 }
 291
 292 bool CSKYTargetInfo::validateAsmConstraint(
 293     const char *&Name, TargetInfo::ConstraintInfo &Info) const {
 294   switch (*Name) {
 295   default:
 296     return false;
 297   case 'a':
 298   case 'b':
 299   case 'c':
 300   case 'y':
 301   case 'l':
 302   case 'h':
 303   case 'w':
 304   case 'v': // A floating-point and vector register.
 305   case 'z':
 306     Info.setAllowsRegister();
 307     return true;
 308   }
 309 }
 310
 311 unsigned CSKYTargetInfo::getMinGlobalAlign(uint64_t Size) const {
 312   if (Size >= 32)
 313     return 32;
 314   return 0;
 315 }