1 //===--- Mips.cpp - Tools Implementations -----------------------*- 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 #include "Mips.h" 11 #include "ToolChains/CommonArgs.h" 12 #include "clang/Driver/Driver.h" 13 #include "clang/Driver/DriverDiagnostic.h" 14 #include "clang/Driver/Options.h" 15 #include "llvm/ADT/StringSwitch.h" 16 #include "llvm/Option/ArgList.h" 17 18 using namespace clang::driver; 19 using namespace clang::driver::tools; 20 using namespace clang; 21 using namespace llvm::opt; 22 23 // Get CPU and ABI names. They are not independent 24 // so we have to calculate them together. 25 void mips::getMipsCPUAndABI(const ArgList &Args, const llvm::Triple &Triple, 26 StringRef &CPUName, StringRef &ABIName) { 27 const char *DefMips32CPU = "mips32r2"; 28 const char *DefMips64CPU = "mips64r2"; 29 30 // MIPS32r6 is the default for mips(el)?-img-linux-gnu and MIPS64r6 is the 31 // default for mips64(el)?-img-linux-gnu. 32 if (Triple.getVendor() == llvm::Triple::ImaginationTechnologies && 33 Triple.isGNUEnvironment()) { 34 DefMips32CPU = "mips32r6"; 35 DefMips64CPU = "mips64r6"; 36 } 37 38 // MIPS64r6 is the default for Android MIPS64 (mips64el-linux-android). 39 if (Triple.isAndroid()) { 40 DefMips32CPU = "mips32"; 41 DefMips64CPU = "mips64r6"; 42 } 43 44 // MIPS3 is the default for mips64*-unknown-openbsd. 45 if (Triple.getOS() == llvm::Triple::OpenBSD) 46 DefMips64CPU = "mips3"; 47 48 // MIPS2 is the default for mips(el)?-unknown-freebsd. 49 // MIPS3 is the default for mips64(el)?-unknown-freebsd. 50 if (Triple.getOS() == llvm::Triple::FreeBSD) { 51 DefMips32CPU = "mips2"; 52 DefMips64CPU = "mips3"; 53 } 54 55 if (Arg *A = Args.getLastArg(clang::driver::options::OPT_march_EQ, 56 options::OPT_mcpu_EQ)) 57 CPUName = A->getValue(); 58 59 if (Arg *A = Args.getLastArg(options::OPT_mabi_EQ)) { 60 ABIName = A->getValue(); 61 // Convert a GNU style Mips ABI name to the name 62 // accepted by LLVM Mips backend. 63 ABIName = llvm::StringSwitch<llvm::StringRef>(ABIName) 64 .Case("32", "o32") 65 .Case("64", "n64") 66 .Default(ABIName); 67 } 68 69 // Setup default CPU and ABI names. 70 if (CPUName.empty() && ABIName.empty()) { 71 switch (Triple.getArch()) { 72 default: 73 llvm_unreachable("Unexpected triple arch name"); 74 case llvm::Triple::mips: 75 case llvm::Triple::mipsel: 76 CPUName = DefMips32CPU; 77 break; 78 case llvm::Triple::mips64: 79 case llvm::Triple::mips64el: 80 CPUName = DefMips64CPU; 81 break; 82 } 83 } 84 85 if (ABIName.empty() && 86 (Triple.getVendor() == llvm::Triple::MipsTechnologies || 87 Triple.getVendor() == llvm::Triple::ImaginationTechnologies)) { 88 ABIName = llvm::StringSwitch<const char *>(CPUName) 89 .Case("mips1", "o32") 90 .Case("mips2", "o32") 91 .Case("mips3", "n64") 92 .Case("mips4", "n64") 93 .Case("mips5", "n64") 94 .Case("mips32", "o32") 95 .Case("mips32r2", "o32") 96 .Case("mips32r3", "o32") 97 .Case("mips32r5", "o32") 98 .Case("mips32r6", "o32") 99 .Case("mips64", "n64") 100 .Case("mips64r2", "n64") 101 .Case("mips64r3", "n64") 102 .Case("mips64r5", "n64") 103 .Case("mips64r6", "n64") 104 .Case("octeon", "n64") 105 .Case("p5600", "o32") 106 .Default(""); 107 } 108 109 if (ABIName.empty()) { 110 // Deduce ABI name from the target triple. 111 ABIName = Triple.isMIPS32() ? "o32" : "n64"; 112 } 113 114 if (CPUName.empty()) { 115 // Deduce CPU name from ABI name. 116 CPUName = llvm::StringSwitch<const char *>(ABIName) 117 .Case("o32", DefMips32CPU) 118 .Cases("n32", "n64", DefMips64CPU) 119 .Default(""); 120 } 121 122 // FIXME: Warn on inconsistent use of -march and -mabi. 123 } 124 125 std::string mips::getMipsABILibSuffix(const ArgList &Args, 126 const llvm::Triple &Triple) { 127 StringRef CPUName, ABIName; 128 tools::mips::getMipsCPUAndABI(Args, Triple, CPUName, ABIName); 129 return llvm::StringSwitch<std::string>(ABIName) 130 .Case("o32", "") 131 .Case("n32", "32") 132 .Case("n64", "64"); 133 } 134 135 // Convert ABI name to the GNU tools acceptable variant. 136 StringRef mips::getGnuCompatibleMipsABIName(StringRef ABI) { 137 return llvm::StringSwitch<llvm::StringRef>(ABI) 138 .Case("o32", "32") 139 .Case("n64", "64") 140 .Default(ABI); 141 } 142 143 // Select the MIPS float ABI as determined by -msoft-float, -mhard-float, 144 // and -mfloat-abi=. 145 mips::FloatABI mips::getMipsFloatABI(const Driver &D, const ArgList &Args) { 146 mips::FloatABI ABI = mips::FloatABI::Invalid; 147 if (Arg *A = 148 Args.getLastArg(options::OPT_msoft_float, options::OPT_mhard_float, 149 options::OPT_mfloat_abi_EQ)) { 150 if (A->getOption().matches(options::OPT_msoft_float)) 151 ABI = mips::FloatABI::Soft; 152 else if (A->getOption().matches(options::OPT_mhard_float)) 153 ABI = mips::FloatABI::Hard; 154 else { 155 ABI = llvm::StringSwitch<mips::FloatABI>(A->getValue()) 156 .Case("soft", mips::FloatABI::Soft) 157 .Case("hard", mips::FloatABI::Hard) 158 .Default(mips::FloatABI::Invalid); 159 if (ABI == mips::FloatABI::Invalid && !StringRef(A->getValue()).empty()) { 160 D.Diag(clang::diag::err_drv_invalid_mfloat_abi) << A->getAsString(Args); 161 ABI = mips::FloatABI::Hard; 162 } 163 } 164 } 165 166 // If unspecified, choose the default based on the platform. 167 if (ABI == mips::FloatABI::Invalid) { 168 // Assume "hard", because it's a default value used by gcc. 169 // When we start to recognize specific target MIPS processors, 170 // we will be able to select the default more correctly. 171 ABI = mips::FloatABI::Hard; 172 } 173 174 assert(ABI != mips::FloatABI::Invalid && "must select an ABI"); 175 return ABI; 176 } 177 178 void mips::getMIPSTargetFeatures(const Driver &D, const llvm::Triple &Triple, 179 const ArgList &Args, 180 std::vector<StringRef> &Features) { 181 StringRef CPUName; 182 StringRef ABIName; 183 getMipsCPUAndABI(Args, Triple, CPUName, ABIName); 184 ABIName = getGnuCompatibleMipsABIName(ABIName); 185 186 // Historically, PIC code for MIPS was associated with -mabicalls, a.k.a 187 // SVR4 abicalls. Static code does not use SVR4 calling sequences. An ABI 188 // extension was developed by Richard Sandiford & Code Sourcery to support 189 // static code calling PIC code (CPIC). For O32 and N32 this means we have 190 // several combinations of PIC/static and abicalls. Pure static, static 191 // with the CPIC extension, and pure PIC code. 192 193 // At final link time, O32 and N32 with CPIC will have another section 194 // added to the binary which contains the stub functions to perform 195 // any fixups required for PIC code. 196 197 // For N64, the situation is more regular: code can either be static 198 // (non-abicalls) or PIC (abicalls). GCC has traditionally picked PIC code 199 // code for N64. Since Clang has already built the relocation model portion 200 // of the commandline, we pick add +noabicalls feature in the N64 static 201 // case. 202 203 // The is another case to be accounted for: -msym32, which enforces that all 204 // symbols have 32 bits in size. In this case, N64 can in theory use CPIC 205 // but it is unsupported. 206 207 // The combinations for N64 are: 208 // a) Static without abicalls and 64bit symbols. 209 // b) Static with abicalls and 32bit symbols. 210 // c) PIC with abicalls and 64bit symbols. 211 212 // For case (a) we need to add +noabicalls for N64. 213 214 bool IsN64 = ABIName == "64"; 215 bool IsPIC = false; 216 bool NonPIC = false; 217 218 Arg *LastPICArg = Args.getLastArg(options::OPT_fPIC, options::OPT_fno_PIC, 219 options::OPT_fpic, options::OPT_fno_pic, 220 options::OPT_fPIE, options::OPT_fno_PIE, 221 options::OPT_fpie, options::OPT_fno_pie); 222 if (LastPICArg) { 223 Option O = LastPICArg->getOption(); 224 NonPIC = 225 (O.matches(options::OPT_fno_PIC) || O.matches(options::OPT_fno_pic) || 226 O.matches(options::OPT_fno_PIE) || O.matches(options::OPT_fno_pie)); 227 IsPIC = 228 (O.matches(options::OPT_fPIC) || O.matches(options::OPT_fpic) || 229 O.matches(options::OPT_fPIE) || O.matches(options::OPT_fpie)); 230 } 231 232 bool UseAbiCalls = false; 233 234 Arg *ABICallsArg = 235 Args.getLastArg(options::OPT_mabicalls, options::OPT_mno_abicalls); 236 UseAbiCalls = 237 !ABICallsArg || ABICallsArg->getOption().matches(options::OPT_mabicalls); 238 239 if (IsN64 && NonPIC && (!ABICallsArg || UseAbiCalls)) { 240 D.Diag(diag::warn_drv_unsupported_pic_with_mabicalls) 241 << LastPICArg->getAsString(Args) << (!ABICallsArg ? 0 : 1); 242 NonPIC = false; 243 } 244 245 if (ABICallsArg && !UseAbiCalls && IsPIC) { 246 D.Diag(diag::err_drv_unsupported_noabicalls_pic); 247 } 248 249 if (!UseAbiCalls) 250 Features.push_back("+noabicalls"); 251 else 252 Features.push_back("-noabicalls"); 253 254 if (Arg *A = Args.getLastArg(options::OPT_mlong_calls, 255 options::OPT_mno_long_calls)) { 256 if (A->getOption().matches(options::OPT_mno_long_calls)) 257 Features.push_back("-long-calls"); 258 else if (!UseAbiCalls) 259 Features.push_back("+long-calls"); 260 else 261 D.Diag(diag::warn_drv_unsupported_longcalls) << (ABICallsArg ? 0 : 1); 262 } 263 264 mips::FloatABI FloatABI = mips::getMipsFloatABI(D, Args); 265 if (FloatABI == mips::FloatABI::Soft) { 266 // FIXME: Note, this is a hack. We need to pass the selected float 267 // mode to the MipsTargetInfoBase to define appropriate macros there. 268 // Now it is the only method. 269 Features.push_back("+soft-float"); 270 } 271 272 if (Arg *A = Args.getLastArg(options::OPT_mnan_EQ)) { 273 StringRef Val = StringRef(A->getValue()); 274 if (Val == "2008") { 275 if (mips::getIEEE754Standard(CPUName) & mips::Std2008) 276 Features.push_back("+nan2008"); 277 else { 278 Features.push_back("-nan2008"); 279 D.Diag(diag::warn_target_unsupported_nan2008) << CPUName; 280 } 281 } else if (Val == "legacy") { 282 if (mips::getIEEE754Standard(CPUName) & mips::Legacy) 283 Features.push_back("-nan2008"); 284 else { 285 Features.push_back("+nan2008"); 286 D.Diag(diag::warn_target_unsupported_nanlegacy) << CPUName; 287 } 288 } else 289 D.Diag(diag::err_drv_unsupported_option_argument) 290 << A->getOption().getName() << Val; 291 } 292 293 if (Arg *A = Args.getLastArg(options::OPT_mabs_EQ)) { 294 StringRef Val = StringRef(A->getValue()); 295 if (Val == "2008") { 296 if (mips::getIEEE754Standard(CPUName) & mips::Std2008) { 297 Features.push_back("+abs2008"); 298 } else { 299 Features.push_back("-abs2008"); 300 D.Diag(diag::warn_target_unsupported_abs2008) << CPUName; 301 } 302 } else if (Val == "legacy") { 303 if (mips::getIEEE754Standard(CPUName) & mips::Legacy) { 304 Features.push_back("-abs2008"); 305 } else { 306 Features.push_back("+abs2008"); 307 D.Diag(diag::warn_target_unsupported_abslegacy) << CPUName; 308 } 309 } else { 310 D.Diag(diag::err_drv_unsupported_option_argument) 311 << A->getOption().getName() << Val; 312 } 313 } 314 315 AddTargetFeature(Args, Features, options::OPT_msingle_float, 316 options::OPT_mdouble_float, "single-float"); 317 AddTargetFeature(Args, Features, options::OPT_mips16, options::OPT_mno_mips16, 318 "mips16"); 319 AddTargetFeature(Args, Features, options::OPT_mmicromips, 320 options::OPT_mno_micromips, "micromips"); 321 AddTargetFeature(Args, Features, options::OPT_mdsp, options::OPT_mno_dsp, 322 "dsp"); 323 AddTargetFeature(Args, Features, options::OPT_mdspr2, options::OPT_mno_dspr2, 324 "dspr2"); 325 AddTargetFeature(Args, Features, options::OPT_mmsa, options::OPT_mno_msa, 326 "msa"); 327 328 // Add the last -mfp32/-mfpxx/-mfp64, if none are given and the ABI is O32 329 // pass -mfpxx, or if none are given and fp64a is default, pass fp64 and 330 // nooddspreg. 331 if (Arg *A = Args.getLastArg(options::OPT_mfp32, options::OPT_mfpxx, 332 options::OPT_mfp64)) { 333 if (A->getOption().matches(options::OPT_mfp32)) 334 Features.push_back("-fp64"); 335 else if (A->getOption().matches(options::OPT_mfpxx)) { 336 Features.push_back("+fpxx"); 337 Features.push_back("+nooddspreg"); 338 } else 339 Features.push_back("+fp64"); 340 } else if (mips::shouldUseFPXX(Args, Triple, CPUName, ABIName, FloatABI)) { 341 Features.push_back("+fpxx"); 342 Features.push_back("+nooddspreg"); 343 } else if (mips::isFP64ADefault(Triple, CPUName)) { 344 Features.push_back("+fp64"); 345 Features.push_back("+nooddspreg"); 346 } 347 348 AddTargetFeature(Args, Features, options::OPT_mno_odd_spreg, 349 options::OPT_modd_spreg, "nooddspreg"); 350 AddTargetFeature(Args, Features, options::OPT_mno_madd4, options::OPT_mmadd4, 351 "nomadd4"); 352 AddTargetFeature(Args, Features, options::OPT_mmt, options::OPT_mno_mt, "mt"); 353 354 if (Arg *A = Args.getLastArg(options::OPT_mindirect_jump_EQ)) { 355 StringRef Val = StringRef(A->getValue()); 356 if (Val == "hazard") { 357 Arg *B = 358 Args.getLastArg(options::OPT_mmicromips, options::OPT_mno_micromips); 359 Arg *C = Args.getLastArg(options::OPT_mips16, options::OPT_mno_mips16); 360 361 if (B && B->getOption().matches(options::OPT_mmicromips)) 362 D.Diag(diag::err_drv_unsupported_indirect_jump_opt) 363 << "hazard" << "micromips"; 364 else if (C && C->getOption().matches(options::OPT_mips16)) 365 D.Diag(diag::err_drv_unsupported_indirect_jump_opt) 366 << "hazard" << "mips16"; 367 else if (mips::supportsIndirectJumpHazardBarrier(CPUName)) 368 Features.push_back("+use-indirect-jump-hazard"); 369 else 370 D.Diag(diag::err_drv_unsupported_indirect_jump_opt) 371 << "hazard" << CPUName; 372 } else 373 D.Diag(diag::err_drv_unknown_indirect_jump_opt) << Val; 374 } 375 } 376 377 mips::IEEE754Standard mips::getIEEE754Standard(StringRef &CPU) { 378 // Strictly speaking, mips32r2 and mips64r2 do not conform to the 379 // IEEE754-2008 standard. Support for this standard was first introduced 380 // in Release 3. However, other compilers have traditionally allowed it 381 // for Release 2 so we should do the same. 382 return (IEEE754Standard)llvm::StringSwitch<int>(CPU) 383 .Case("mips1", Legacy) 384 .Case("mips2", Legacy) 385 .Case("mips3", Legacy) 386 .Case("mips4", Legacy) 387 .Case("mips5", Legacy) 388 .Case("mips32", Legacy) 389 .Case("mips32r2", Legacy | Std2008) 390 .Case("mips32r3", Legacy | Std2008) 391 .Case("mips32r5", Legacy | Std2008) 392 .Case("mips32r6", Std2008) 393 .Case("mips64", Legacy) 394 .Case("mips64r2", Legacy | Std2008) 395 .Case("mips64r3", Legacy | Std2008) 396 .Case("mips64r5", Legacy | Std2008) 397 .Case("mips64r6", Std2008) 398 .Default(Std2008); 399 } 400 401 bool mips::hasCompactBranches(StringRef &CPU) { 402 // mips32r6 and mips64r6 have compact branches. 403 return llvm::StringSwitch<bool>(CPU) 404 .Case("mips32r6", true) 405 .Case("mips64r6", true) 406 .Default(false); 407 } 408 409 bool mips::hasMipsAbiArg(const ArgList &Args, const char *Value) { 410 Arg *A = Args.getLastArg(options::OPT_mabi_EQ); 411 return A && (A->getValue() == StringRef(Value)); 412 } 413 414 bool mips::isUCLibc(const ArgList &Args) { 415 Arg *A = Args.getLastArg(options::OPT_m_libc_Group); 416 return A && A->getOption().matches(options::OPT_muclibc); 417 } 418 419 bool mips::isNaN2008(const ArgList &Args, const llvm::Triple &Triple) { 420 if (Arg *NaNArg = Args.getLastArg(options::OPT_mnan_EQ)) 421 return llvm::StringSwitch<bool>(NaNArg->getValue()) 422 .Case("2008", true) 423 .Case("legacy", false) 424 .Default(false); 425 426 // NaN2008 is the default for MIPS32r6/MIPS64r6. 427 return llvm::StringSwitch<bool>(getCPUName(Args, Triple)) 428 .Cases("mips32r6", "mips64r6", true) 429 .Default(false); 430 431 return false; 432 } 433 434 bool mips::isFP64ADefault(const llvm::Triple &Triple, StringRef CPUName) { 435 if (!Triple.isAndroid()) 436 return false; 437 438 // Android MIPS32R6 defaults to FP64A. 439 return llvm::StringSwitch<bool>(CPUName) 440 .Case("mips32r6", true) 441 .Default(false); 442 } 443 444 bool mips::isFPXXDefault(const llvm::Triple &Triple, StringRef CPUName, 445 StringRef ABIName, mips::FloatABI FloatABI) { 446 if (Triple.getVendor() != llvm::Triple::ImaginationTechnologies && 447 Triple.getVendor() != llvm::Triple::MipsTechnologies && 448 !Triple.isAndroid()) 449 return false; 450 451 if (ABIName != "32") 452 return false; 453 454 // FPXX shouldn't be used if either -msoft-float or -mfloat-abi=soft is 455 // present. 456 if (FloatABI == mips::FloatABI::Soft) 457 return false; 458 459 return llvm::StringSwitch<bool>(CPUName) 460 .Cases("mips2", "mips3", "mips4", "mips5", true) 461 .Cases("mips32", "mips32r2", "mips32r3", "mips32r5", true) 462 .Cases("mips64", "mips64r2", "mips64r3", "mips64r5", true) 463 .Default(false); 464 } 465 466 bool mips::shouldUseFPXX(const ArgList &Args, const llvm::Triple &Triple, 467 StringRef CPUName, StringRef ABIName, 468 mips::FloatABI FloatABI) { 469 bool UseFPXX = isFPXXDefault(Triple, CPUName, ABIName, FloatABI); 470 471 // FPXX shouldn't be used if -msingle-float is present. 472 if (Arg *A = Args.getLastArg(options::OPT_msingle_float, 473 options::OPT_mdouble_float)) 474 if (A->getOption().matches(options::OPT_msingle_float)) 475 UseFPXX = false; 476 477 return UseFPXX; 478 } 479 480 bool mips::supportsIndirectJumpHazardBarrier(StringRef &CPU) { 481 // Supporting the hazard barrier method of dealing with indirect 482 // jumps requires MIPSR2 support. 483 return llvm::StringSwitch<bool>(CPU) 484 .Case("mips32r2", true) 485 .Case("mips32r3", true) 486 .Case("mips32r5", true) 487 .Case("mips32r6", true) 488 .Case("mips64r2", true) 489 .Case("mips64r3", true) 490 .Case("mips64r5", true) 491 .Case("mips64r6", true) 492 .Case("octeon", true) 493 .Case("p5600", true) 494 .Default(false); 495 } 496