| //===--- LoongArch.cpp - LoongArch Helpers for Tools ------------*- C++ -*-===// |
| // |
| // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. |
| // See https://llvm.org/LICENSE.txt for license information. |
| // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception |
| // |
| //===----------------------------------------------------------------------===// |
| |
| #include "LoongArch.h" |
| #include "ToolChains/CommonArgs.h" |
| #include "clang/Basic/DiagnosticDriver.h" |
| #include "clang/Driver/Driver.h" |
| #include "clang/Driver/DriverDiagnostic.h" |
| #include "clang/Driver/Options.h" |
| #include "llvm/TargetParser/Host.h" |
| #include "llvm/TargetParser/LoongArchTargetParser.h" |
| |
| using namespace clang::driver; |
| using namespace clang::driver::tools; |
| using namespace clang; |
| using namespace llvm::opt; |
| |
| StringRef loongarch::getLoongArchABI(const Driver &D, const ArgList &Args, |
| const llvm::Triple &Triple) { |
| assert((Triple.getArch() == llvm::Triple::loongarch32 || |
| Triple.getArch() == llvm::Triple::loongarch64) && |
| "Unexpected triple"); |
| bool IsLA32 = Triple.getArch() == llvm::Triple::loongarch32; |
| |
| // Record -mabi value for later use. |
| const Arg *MABIArg = Args.getLastArg(options::OPT_mabi_EQ); |
| StringRef MABIValue; |
| if (MABIArg) { |
| MABIValue = MABIArg->getValue(); |
| } |
| |
| // Parse -mfpu value for later use. |
| const Arg *MFPUArg = Args.getLastArg(options::OPT_mfpu_EQ); |
| int FPU = -1; |
| if (MFPUArg) { |
| StringRef V = MFPUArg->getValue(); |
| if (V == "64") |
| FPU = 64; |
| else if (V == "32") |
| FPU = 32; |
| else if (V == "0" || V == "none") |
| FPU = 0; |
| else |
| D.Diag(diag::err_drv_loongarch_invalid_mfpu_EQ) << V; |
| } |
| |
| // Check -m*-float firstly since they have highest priority. |
| if (const Arg *A = Args.getLastArg(options::OPT_mdouble_float, |
| options::OPT_msingle_float, |
| options::OPT_msoft_float)) { |
| StringRef ImpliedABI; |
| int ImpliedFPU = -1; |
| if (A->getOption().matches(options::OPT_mdouble_float)) { |
| ImpliedABI = IsLA32 ? "ilp32d" : "lp64d"; |
| ImpliedFPU = 64; |
| } |
| if (A->getOption().matches(options::OPT_msingle_float)) { |
| ImpliedABI = IsLA32 ? "ilp32f" : "lp64f"; |
| ImpliedFPU = 32; |
| } |
| if (A->getOption().matches(options::OPT_msoft_float)) { |
| ImpliedABI = IsLA32 ? "ilp32s" : "lp64s"; |
| ImpliedFPU = 0; |
| } |
| |
| // Check `-mabi=` and `-mfpu=` settings and report if they conflict with |
| // the higher-priority settings implied by -m*-float. |
| // |
| // ImpliedABI and ImpliedFPU are guaranteed to have valid values because |
| // one of the match arms must match if execution can arrive here at all. |
| if (!MABIValue.empty() && ImpliedABI != MABIValue) |
| D.Diag(diag::warn_drv_loongarch_conflicting_implied_val) |
| << MABIArg->getAsString(Args) << A->getAsString(Args) << ImpliedABI; |
| |
| if (FPU != -1 && ImpliedFPU != FPU) |
| D.Diag(diag::warn_drv_loongarch_conflicting_implied_val) |
| << MFPUArg->getAsString(Args) << A->getAsString(Args) << ImpliedFPU; |
| |
| return ImpliedABI; |
| } |
| |
| // If `-mabi=` is specified, use it. |
| if (!MABIValue.empty()) |
| return MABIValue; |
| |
| // Select abi based on -mfpu=xx. |
| switch (FPU) { |
| case 64: |
| return IsLA32 ? "ilp32d" : "lp64d"; |
| case 32: |
| return IsLA32 ? "ilp32f" : "lp64f"; |
| case 0: |
| return IsLA32 ? "ilp32s" : "lp64s"; |
| } |
| |
| // Choose a default based on the triple. |
| // Honor the explicit ABI modifier suffix in triple's environment part if |
| // present, falling back to {ILP32,LP64}D otherwise. |
| switch (Triple.getEnvironment()) { |
| case llvm::Triple::GNUSF: |
| return IsLA32 ? "ilp32s" : "lp64s"; |
| case llvm::Triple::GNUF32: |
| return IsLA32 ? "ilp32f" : "lp64f"; |
| case llvm::Triple::GNUF64: |
| // This was originally permitted (and indeed the canonical way) to |
| // represent the {ILP32,LP64}D ABIs, but in Feb 2023 Loongson decided to |
| // drop the explicit suffix in favor of unmarked `-gnu` for the |
| // "general-purpose" ABIs, among other non-technical reasons. |
| // |
| // The spec change did not mention whether existing usages of "gnuf64" |
| // shall remain valid or not, so we are going to continue recognizing it |
| // for some time, until it is clear that everyone else has migrated away |
| // from it. |
| [[fallthrough]]; |
| case llvm::Triple::GNU: |
| default: |
| return IsLA32 ? "ilp32d" : "lp64d"; |
| } |
| } |
| |
| void loongarch::getLoongArchTargetFeatures(const Driver &D, |
| const llvm::Triple &Triple, |
| const ArgList &Args, |
| std::vector<StringRef> &Features) { |
| std::string ArchName; |
| if (const Arg *A = Args.getLastArg(options::OPT_march_EQ)) |
| ArchName = A->getValue(); |
| ArchName = postProcessTargetCPUString(ArchName, Triple); |
| llvm::LoongArch::getArchFeatures(ArchName, Features); |
| |
| // Select floating-point features determined by -mdouble-float, |
| // -msingle-float, -msoft-float and -mfpu. |
| // Note: -m*-float wins any other options. |
| if (const Arg *A = Args.getLastArg(options::OPT_mdouble_float, |
| options::OPT_msingle_float, |
| options::OPT_msoft_float)) { |
| if (A->getOption().matches(options::OPT_mdouble_float)) { |
| Features.push_back("+f"); |
| Features.push_back("+d"); |
| } else if (A->getOption().matches(options::OPT_msingle_float)) { |
| Features.push_back("+f"); |
| Features.push_back("-d"); |
| } else /*Soft-float*/ { |
| Features.push_back("-f"); |
| Features.push_back("-d"); |
| } |
| } else if (const Arg *A = Args.getLastArg(options::OPT_mfpu_EQ)) { |
| StringRef FPU = A->getValue(); |
| if (FPU == "64") { |
| Features.push_back("+f"); |
| Features.push_back("+d"); |
| } else if (FPU == "32") { |
| Features.push_back("+f"); |
| Features.push_back("-d"); |
| } else if (FPU == "0" || FPU == "none") { |
| Features.push_back("-f"); |
| Features.push_back("-d"); |
| } else { |
| D.Diag(diag::err_drv_loongarch_invalid_mfpu_EQ) << FPU; |
| } |
| } |
| |
| // Select the `ual` feature determined by -m[no-]unaligned-access |
| // or the alias -m[no-]strict-align. |
| AddTargetFeature(Args, Features, options::OPT_munaligned_access, |
| options::OPT_mno_unaligned_access, "ual"); |
| |
| // Accept but warn about these TargetSpecific options. |
| if (Arg *A = Args.getLastArgNoClaim(options::OPT_mabi_EQ)) |
| A->ignoreTargetSpecific(); |
| if (Arg *A = Args.getLastArgNoClaim(options::OPT_mfpu_EQ)) |
| A->ignoreTargetSpecific(); |
| |
| // Select lsx feature determined by -m[no-]lsx. |
| if (const Arg *A = Args.getLastArg(options::OPT_mlsx, options::OPT_mno_lsx)) { |
| // LSX depends on 64-bit FPU. |
| // -m*-float and -mfpu=none/0/32 conflict with -mlsx. |
| if (A->getOption().matches(options::OPT_mlsx)) { |
| if (llvm::find(Features, "-d") != Features.end()) |
| D.Diag(diag::err_drv_loongarch_wrong_fpu_width_for_lsx); |
| else /*-mlsx*/ |
| Features.push_back("+lsx"); |
| } else /*-mno-lsx*/ { |
| Features.push_back("-lsx"); |
| } |
| } |
| |
| // Select lasx feature determined by -m[no-]lasx. |
| if (const Arg *A = |
| Args.getLastArg(options::OPT_mlasx, options::OPT_mno_lasx)) { |
| // LASX depends on 64-bit FPU and LSX. |
| // -mno-lsx conflicts with -mlasx. |
| if (A->getOption().matches(options::OPT_mlasx)) { |
| if (llvm::find(Features, "-d") != Features.end()) |
| D.Diag(diag::err_drv_loongarch_wrong_fpu_width_for_lasx); |
| else if (llvm::find(Features, "-lsx") != Features.end()) |
| D.Diag(diag::err_drv_loongarch_invalid_simd_option_combination); |
| else { /*-mlasx*/ |
| Features.push_back("+lsx"); |
| Features.push_back("+lasx"); |
| } |
| } else /*-mno-lasx*/ |
| Features.push_back("-lasx"); |
| } |
| } |
| |
| std::string loongarch::postProcessTargetCPUString(const std::string &CPU, |
| const llvm::Triple &Triple) { |
| std::string CPUString = CPU; |
| if (CPUString == "native") { |
| CPUString = llvm::sys::getHostCPUName(); |
| if (CPUString == "generic") |
| CPUString = llvm::LoongArch::getDefaultArch(Triple.isLoongArch64()); |
| } |
| if (CPUString.empty()) |
| CPUString = llvm::LoongArch::getDefaultArch(Triple.isLoongArch64()); |
| return CPUString; |
| } |
| |
| std::string loongarch::getLoongArchTargetCPU(const llvm::opt::ArgList &Args, |
| const llvm::Triple &Triple) { |
| std::string CPU; |
| // If we have -march, use that. |
| if (const Arg *A = Args.getLastArg(options::OPT_march_EQ)) |
| CPU = A->getValue(); |
| return postProcessTargetCPUString(CPU, Triple); |
| } |