contrib/llvm/tools/clang/lib/Basic/Targets/Mips.h

   1 //===--- Mips.h - Declare Mips target feature support -----------*- C++ -*-===//
   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 declares Mips TargetInfo objects.
  11 //
  12 //===----------------------------------------------------------------------===//
  13
  14 #ifndef LLVM_CLANG_LIB_BASIC_TARGETS_MIPS_H
  15 #define LLVM_CLANG_LIB_BASIC_TARGETS_MIPS_H
  16
  17 #include "clang/Basic/TargetInfo.h"
  18 #include "clang/Basic/TargetOptions.h"
  19 #include "llvm/ADT/Triple.h"
  20 #include "llvm/Support/Compiler.h"
  21
  22 namespace clang {
  23 namespace targets {
  24
  25 class LLVM_LIBRARY_VISIBILITY MipsTargetInfo : public TargetInfo {
  26   void setDataLayout() {
  27     StringRef Layout;
  28
  29     if (ABI == "o32")
  30       Layout = "m:m-p:32:32-i8:8:32-i16:16:32-i64:64-n32-S64";
  31     else if (ABI == "n32")
  32       Layout = "m:e-p:32:32-i8:8:32-i16:16:32-i64:64-n32:64-S128";
  33     else if (ABI == "n64")
  34       Layout = "m:e-i8:8:32-i16:16:32-i64:64-n32:64-S128";
  35     else
  36       llvm_unreachable("Invalid ABI");
  37
  38     if (BigEndian)
  39       resetDataLayout(("E-" + Layout).str());
  40     else
  41       resetDataLayout(("e-" + Layout).str());
  42   }
  43
  44   static const Builtin::Info BuiltinInfo[];
  45   std::string CPU;
  46   bool IsMips16;
  47   bool IsMicromips;
  48   bool IsNan2008;
  49   bool IsAbs2008;
  50   bool IsSingleFloat;
  51   bool IsNoABICalls;
  52   bool CanUseBSDABICalls;
  53   enum MipsFloatABI { HardFloat, SoftFloat } FloatABI;
  54   enum DspRevEnum { NoDSP, DSP1, DSP2 } DspRev;
  55   bool HasMSA;
  56   bool DisableMadd4;
  57   bool UseIndirectJumpHazard;
  58
  59 protected:
  60   bool HasFP64;
  61   std::string ABI;
  62
  63 public:
  64   MipsTargetInfo(const llvm::Triple &Triple, const TargetOptions &)
  65       : TargetInfo(Triple), IsMips16(false), IsMicromips(false),
  66         IsNan2008(false), IsAbs2008(false), IsSingleFloat(false),
  67         IsNoABICalls(false), CanUseBSDABICalls(false), FloatABI(HardFloat),
  68         DspRev(NoDSP), HasMSA(false), DisableMadd4(false),
  69         UseIndirectJumpHazard(false), HasFP64(false) {
  70     TheCXXABI.set(TargetCXXABI::GenericMIPS);
  71
  72     setABI((getTriple().getArch() == llvm::Triple::mips ||
  73             getTriple().getArch() == llvm::Triple::mipsel)
  74                ? "o32"
  75                : "n64");
  76
  77     CPU = ABI == "o32" ? "mips32r2" : "mips64r2";
  78
  79     CanUseBSDABICalls = Triple.getOS() == llvm::Triple::FreeBSD ||
  80                         Triple.getOS() == llvm::Triple::OpenBSD;
  81   }
  82
  83   bool isIEEE754_2008Default() const {
  84     return CPU == "mips32r6" || CPU == "mips64r6";
  85   }
  86
  87   bool isFP64Default() const {
  88     return CPU == "mips32r6" || ABI == "n32" || ABI == "n64" || ABI == "64";
  89   }
  90
  91   bool isNan2008() const override { return IsNan2008; }
  92
  93   bool processorSupportsGPR64() const;
  94
  95   StringRef getABI() const override { return ABI; }
  96
  97   bool setABI(const std::string &Name) override {
  98     if (Name == "o32") {
  99       setO32ABITypes();
 100       ABI = Name;
 101       return true;
 102     }
 103
 104     if (Name == "n32") {
 105       setN32ABITypes();
 106       ABI = Name;
 107       return true;
 108     }
 109     if (Name == "n64") {
 110       setN64ABITypes();
 111       ABI = Name;
 112       return true;
 113     }
 114     return false;
 115   }
 116
 117   void setO32ABITypes() {
 118     Int64Type = SignedLongLong;
 119     IntMaxType = Int64Type;
 120     LongDoubleFormat = &llvm::APFloat::IEEEdouble();
 121     LongDoubleWidth = LongDoubleAlign = 64;
 122     LongWidth = LongAlign = 32;
 123     MaxAtomicPromoteWidth = MaxAtomicInlineWidth = 32;
 124     PointerWidth = PointerAlign = 32;
 125     PtrDiffType = SignedInt;
 126     SizeType = UnsignedInt;
 127     SuitableAlign = 64;
 128   }
 129
 130   void setN32N64ABITypes() {
 131     LongDoubleWidth = LongDoubleAlign = 128;
 132     LongDoubleFormat = &llvm::APFloat::IEEEquad();
 133     if (getTriple().getOS() == llvm::Triple::FreeBSD) {
 134       LongDoubleWidth = LongDoubleAlign = 64;
 135       LongDoubleFormat = &llvm::APFloat::IEEEdouble();
 136     }
 137     MaxAtomicPromoteWidth = MaxAtomicInlineWidth = 64;
 138     SuitableAlign = 128;
 139   }
 140
 141   void setN64ABITypes() {
 142     setN32N64ABITypes();
 143     if (getTriple().getOS() == llvm::Triple::OpenBSD) {
 144       Int64Type = SignedLongLong;
 145     } else {
 146       Int64Type = SignedLong;
 147     }
 148     IntMaxType = Int64Type;
 149     LongWidth = LongAlign = 64;
 150     PointerWidth = PointerAlign = 64;
 151     PtrDiffType = SignedLong;
 152     SizeType = UnsignedLong;
 153   }
 154
 155   void setN32ABITypes() {
 156     setN32N64ABITypes();
 157     Int64Type = SignedLongLong;
 158     IntMaxType = Int64Type;
 159     LongWidth = LongAlign = 32;
 160     PointerWidth = PointerAlign = 32;
 161     PtrDiffType = SignedInt;
 162     SizeType = UnsignedInt;
 163   }
 164
 165   bool isValidCPUName(StringRef Name) const override;
 166
 167   bool setCPU(const std::string &Name) override {
 168     CPU = Name;
 169     return isValidCPUName(Name);
 170   }
 171
 172   const std::string &getCPU() const { return CPU; }
 173   bool
 174   initFeatureMap(llvm::StringMap<bool> &Features, DiagnosticsEngine &Diags,
 175                  StringRef CPU,
 176                  const std::vector<std::string> &FeaturesVec) const override {
 177     if (CPU.empty())
 178       CPU = getCPU();
 179     if (CPU == "octeon")
 180       Features["mips64r2"] = Features["cnmips"] = true;
 181     else
 182       Features[CPU] = true;
 183     return TargetInfo::initFeatureMap(Features, Diags, CPU, FeaturesVec);
 184   }
 185
 186   void getTargetDefines(const LangOptions &Opts,
 187                         MacroBuilder &Builder) const override;
 188
 189   ArrayRef<Builtin::Info> getTargetBuiltins() const override;
 190
 191   bool hasFeature(StringRef Feature) const override;
 192
 193   BuiltinVaListKind getBuiltinVaListKind() const override {
 194     return TargetInfo::VoidPtrBuiltinVaList;
 195   }
 196
 197   ArrayRef<const char *> getGCCRegNames() const override {
 198     static const char *const GCCRegNames[] = {
 199         // CPU register names
 200         // Must match second column of GCCRegAliases
 201         "$0", "$1", "$2", "$3", "$4", "$5", "$6", "$7", "$8", "$9", "$10",
 202         "$11", "$12", "$13", "$14", "$15", "$16", "$17", "$18", "$19", "$20",
 203         "$21", "$22", "$23", "$24", "$25", "$26", "$27", "$28", "$29", "$30",
 204         "$31",
 205         // Floating point register names
 206         "$f0", "$f1", "$f2", "$f3", "$f4", "$f5", "$f6", "$f7", "$f8", "$f9",
 207         "$f10", "$f11", "$f12", "$f13", "$f14", "$f15", "$f16", "$f17", "$f18",
 208         "$f19", "$f20", "$f21", "$f22", "$f23", "$f24", "$f25", "$f26", "$f27",
 209         "$f28", "$f29", "$f30", "$f31",
 210         // Hi/lo and condition register names
 211         "hi", "lo", "", "$fcc0", "$fcc1", "$fcc2", "$fcc3", "$fcc4", "$fcc5",
 212         "$fcc6", "$fcc7", "$ac1hi", "$ac1lo", "$ac2hi", "$ac2lo", "$ac3hi",
 213         "$ac3lo",
 214         // MSA register names
 215         "$w0", "$w1", "$w2", "$w3", "$w4", "$w5", "$w6", "$w7", "$w8", "$w9",
 216         "$w10", "$w11", "$w12", "$w13", "$w14", "$w15", "$w16", "$w17", "$w18",
 217         "$w19", "$w20", "$w21", "$w22", "$w23", "$w24", "$w25", "$w26", "$w27",
 218         "$w28", "$w29", "$w30", "$w31",
 219         // MSA control register names
 220         "$msair", "$msacsr", "$msaaccess", "$msasave", "$msamodify",
 221         "$msarequest", "$msamap", "$msaunmap"
 222     };
 223     return llvm::makeArrayRef(GCCRegNames);
 224   }
 225
 226   bool validateAsmConstraint(const char *&Name,
 227                              TargetInfo::ConstraintInfo &Info) const override {
 228     switch (*Name) {
 229     default:
 230       return false;
 231     case 'r': // CPU registers.
 232     case 'd': // Equivalent to "r" unless generating MIPS16 code.
 233     case 'y': // Equivalent to "r", backward compatibility only.
 234     case 'f': // floating-point registers.
 235     case 'c': // $25 for indirect jumps
 236     case 'l': // lo register
 237     case 'x': // hilo register pair
 238       Info.setAllowsRegister();
 239       return true;
 240     case 'I': // Signed 16-bit constant
 241     case 'J': // Integer 0
 242     case 'K': // Unsigned 16-bit constant
 243     case 'L': // Signed 32-bit constant, lower 16-bit zeros (for lui)
 244     case 'M': // Constants not loadable via lui, addiu, or ori
 245     case 'N': // Constant -1 to -65535
 246     case 'O': // A signed 15-bit constant
 247     case 'P': // A constant between 1 go 65535
 248       return true;
 249     case 'R': // An address that can be used in a non-macro load or store
 250       Info.setAllowsMemory();
 251       return true;
 252     case 'Z':
 253       if (Name[1] == 'C') { // An address usable by ll, and sc.
 254         Info.setAllowsMemory();
 255         Name++; // Skip over 'Z'.
 256         return true;
 257       }
 258       return false;
 259     }
 260   }
 261
 262   std::string convertConstraint(const char *&Constraint) const override {
 263     std::string R;
 264     switch (*Constraint) {
 265     case 'Z': // Two-character constraint; add "^" hint for later parsing.
 266       if (Constraint[1] == 'C') {
 267         R = std::string("^") + std::string(Constraint, 2);
 268         Constraint++;
 269         return R;
 270       }
 271       break;
 272     }
 273     return TargetInfo::convertConstraint(Constraint);
 274   }
 275
 276   const char *getClobbers() const override {
 277     // In GCC, $1 is not widely used in generated code (it's used only in a few
 278     // specific situations), so there is no real need for users to add it to
 279     // the clobbers list if they want to use it in their inline assembly code.
 280     //
 281     // In LLVM, $1 is treated as a normal GPR and is always allocatable during
 282     // code generation, so using it in inline assembly without adding it to the
 283     // clobbers list can cause conflicts between the inline assembly code and
 284     // the surrounding generated code.
 285     //
 286     // Another problem is that LLVM is allowed to choose $1 for inline assembly
 287     // operands, which will conflict with the ".set at" assembler option (which
 288     // we use only for inline assembly, in order to maintain compatibility with
 289     // GCC) and will also conflict with the user's usage of $1.
 290     //
 291     // The easiest way to avoid these conflicts and keep $1 as an allocatable
 292     // register for generated code is to automatically clobber $1 for all inline
 293     // assembly code.
 294     //
 295     // FIXME: We should automatically clobber $1 only for inline assembly code
 296     // which actually uses it. This would allow LLVM to use $1 for inline
 297     // assembly operands if the user's assembly code doesn't use it.
 298     return "~{$1}";
 299   }
 300
 301   bool handleTargetFeatures(std::vector<std::string> &Features,
 302                             DiagnosticsEngine &Diags) override {
 303     IsMips16 = false;
 304     IsMicromips = false;
 305     IsNan2008 = isIEEE754_2008Default();
 306     IsAbs2008 = isIEEE754_2008Default();
 307     IsSingleFloat = false;
 308     FloatABI = HardFloat;
 309     DspRev = NoDSP;
 310     HasFP64 = isFP64Default();
 311
 312     for (const auto &Feature : Features) {
 313       if (Feature == "+single-float")
 314         IsSingleFloat = true;
 315       else if (Feature == "+soft-float")
 316         FloatABI = SoftFloat;
 317       else if (Feature == "+mips16")
 318         IsMips16 = true;
 319       else if (Feature == "+micromips")
 320         IsMicromips = true;
 321       else if (Feature == "+dsp")
 322         DspRev = std::max(DspRev, DSP1);
 323       else if (Feature == "+dspr2")
 324         DspRev = std::max(DspRev, DSP2);
 325       else if (Feature == "+msa")
 326         HasMSA = true;
 327       else if (Feature == "+nomadd4")
 328         DisableMadd4 = true;
 329       else if (Feature == "+fp64")
 330         HasFP64 = true;
 331       else if (Feature == "-fp64")
 332         HasFP64 = false;
 333       else if (Feature == "+nan2008")
 334         IsNan2008 = true;
 335       else if (Feature == "-nan2008")
 336         IsNan2008 = false;
 337       else if (Feature == "+abs2008")
 338         IsAbs2008 = true;
 339       else if (Feature == "-abs2008")
 340         IsAbs2008 = false;
 341       else if (Feature == "+noabicalls")
 342         IsNoABICalls = true;
 343       else if (Feature == "+use-indirect-jump-hazard")
 344         UseIndirectJumpHazard = true;
 345     }
 346
 347     setDataLayout();
 348
 349     return true;
 350   }
 351
 352   int getEHDataRegisterNumber(unsigned RegNo) const override {
 353     if (RegNo == 0)
 354       return 4;
 355     if (RegNo == 1)
 356       return 5;
 357     return -1;
 358   }
 359
 360   bool isCLZForZeroUndef() const override { return false; }
 361
 362   ArrayRef<TargetInfo::GCCRegAlias> getGCCRegAliases() const override {
 363     static const TargetInfo::GCCRegAlias O32RegAliases[] = {
 364         {{"at"}, "$1"},  {{"v0"}, "$2"},         {{"v1"}, "$3"},
 365         {{"a0"}, "$4"},  {{"a1"}, "$5"},         {{"a2"}, "$6"},
 366         {{"a3"}, "$7"},  {{"t0"}, "$8"},         {{"t1"}, "$9"},
 367         {{"t2"}, "$10"}, {{"t3"}, "$11"},        {{"t4"}, "$12"},
 368         {{"t5"}, "$13"}, {{"t6"}, "$14"},        {{"t7"}, "$15"},
 369         {{"s0"}, "$16"}, {{"s1"}, "$17"},        {{"s2"}, "$18"},
 370         {{"s3"}, "$19"}, {{"s4"}, "$20"},        {{"s5"}, "$21"},
 371         {{"s6"}, "$22"}, {{"s7"}, "$23"},        {{"t8"}, "$24"},
 372         {{"t9"}, "$25"}, {{"k0"}, "$26"},        {{"k1"}, "$27"},
 373         {{"gp"}, "$28"}, {{"sp", "$sp"}, "$29"}, {{"fp", "$fp"}, "$30"},
 374         {{"ra"}, "$31"}
 375     };
 376     static const TargetInfo::GCCRegAlias NewABIRegAliases[] = {
 377         {{"at"}, "$1"},  {{"v0"}, "$2"},         {{"v1"}, "$3"},
 378         {{"a0"}, "$4"},  {{"a1"}, "$5"},         {{"a2"}, "$6"},
 379         {{"a3"}, "$7"},  {{"a4"}, "$8"},         {{"a5"}, "$9"},
 380         {{"a6"}, "$10"}, {{"a7"}, "$11"},        {{"t0"}, "$12"},
 381         {{"t1"}, "$13"}, {{"t2"}, "$14"},        {{"t3"}, "$15"},
 382         {{"s0"}, "$16"}, {{"s1"}, "$17"},        {{"s2"}, "$18"},
 383         {{"s3"}, "$19"}, {{"s4"}, "$20"},        {{"s5"}, "$21"},
 384         {{"s6"}, "$22"}, {{"s7"}, "$23"},        {{"t8"}, "$24"},
 385         {{"t9"}, "$25"}, {{"k0"}, "$26"},        {{"k1"}, "$27"},
 386         {{"gp"}, "$28"}, {{"sp", "$sp"}, "$29"}, {{"fp", "$fp"}, "$30"},
 387         {{"ra"}, "$31"}
 388     };
 389     if (ABI == "o32")
 390       return llvm::makeArrayRef(O32RegAliases);
 391     return llvm::makeArrayRef(NewABIRegAliases);
 392   }
 393
 394   bool hasInt128Type() const override { return ABI == "n32" || ABI == "n64"; }
 395
 396   bool validateTarget(DiagnosticsEngine &Diags) const override;
 397 };
 398 } // namespace targets
 399 } // namespace clang
 400
 401 #endif // LLVM_CLANG_LIB_BASIC_TARGETS_MIPS_H