//===--- RISCV.h - Declare RISCV target feature support ---------*- 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

//

//===----------------------------------------------------------------------===//

//

// This file declares RISCV TargetInfo objects.

//

//===----------------------------------------------------------------------===//

#ifndef LLVM_CLANG_LIB_BASIC_TARGETS_RISCV_H

#define LLVM_CLANG_LIB_BASIC_TARGETS_RISCV_H

#include "clang/Basic/TargetInfo.h"

#include "clang/Basic/TargetOptions.h"

#include "llvm/ADT/Triple.h"

#include "llvm/Support/Compiler.h"

namespace clang {

namespace targets {

// RISC-V Target

class RISCVTargetInfo : public TargetInfo {

protected:

  std::string ABI, CPU;

  bool HasM = false;

  bool HasA = false;

  bool HasF = false;

  bool HasD = false;

  bool HasC = false;

  bool HasB = false;

  bool HasV = false;

  bool HasZba = false;

  bool HasZbb = false;

  bool HasZbc = false;

  bool HasZbe = false;

  bool HasZbf = false;

  bool HasZbm = false;

  bool HasZbp = false;

  bool HasZbproposedc = false;

  bool HasZbr = false;

  bool HasZbs = false;

  bool HasZbt = false;

  bool HasZfh = false;

  bool HasZvamo = false;

  bool HasZvlsseg = false;

  static const Builtin::Info BuiltinInfo[];

public:

  RISCVTargetInfo(const llvm::Triple &Triple, const TargetOptions &)

      : TargetInfo(Triple) {

    LongDoubleWidth = 128;

    LongDoubleAlign = 128;

    LongDoubleFormat = &llvm::APFloat::IEEEquad();

    SuitableAlign = 128;

    WCharType = SignedInt;

    WIntType = UnsignedInt;

    HasRISCVVTypes = true;

    MCountName = "_mcount";

    HasFloat16 = true;

  }

  bool setCPU(const std::string &Name) override {

    if (!isValidCPUName(Name))

      return false;

    CPU = Name;

    return true;

  }

  StringRef getABI() const override { return ABI; }

  void getTargetDefines(const LangOptions &Opts,

                        MacroBuilder &Builder) const override;

  ArrayRef<Builtin::Info> getTargetBuiltins() const override;

  BuiltinVaListKind getBuiltinVaListKind() const override {

    return TargetInfo::VoidPtrBuiltinVaList;

  }

  const char *getClobbers() const override { return ""; }

  ArrayRef<const char *> getGCCRegNames() const override;

  int getEHDataRegisterNumber(unsigned RegNo) const override {

    if (RegNo == 0)

      return 10;

    else if (RegNo == 1)

      return 11;

    else

      return -1;

  }

  ArrayRef<TargetInfo::GCCRegAlias> getGCCRegAliases() const override;

  bool validateAsmConstraint(const char *&Name,

                             TargetInfo::ConstraintInfo &Info) const override;

  std::string convertConstraint(const char *&Constraint) const override;

  bool

  initFeatureMap(llvm::StringMap<bool> &Features, DiagnosticsEngine &Diags,

                 StringRef CPU,

                 const std::vector<std::string> &FeaturesVec) const override;

  bool hasFeature(StringRef Feature) const override;

  bool handleTargetFeatures(std::vector<std::string> &Features,

                            DiagnosticsEngine &Diags) override;

  bool hasExtIntType() const override { return true; }

};

class LLVM_LIBRARY_VISIBILITY RISCV32TargetInfo : public RISCVTargetInfo {

public:

  RISCV32TargetInfo(const llvm::Triple &Triple, const TargetOptions &Opts)

      : RISCVTargetInfo(Triple, Opts) {

    IntPtrType = SignedInt;

    PtrDiffType = SignedInt;

    SizeType = UnsignedInt;

    resetDataLayout("e-m:e-p:32:32-i64:64-n32-S128");

  }

clang::targets::RISCV32TargetInfo::RISCV32TargetInfo(llvm::Triple const&, clang::TargetOptions const&)

Line

Count

Source

118

56

      : RISCVTargetInfo(Triple, Opts) {

119

56

    IntPtrType = SignedInt;

120

56

    PtrDiffType = SignedInt;

121

56

    SizeType = UnsignedInt;

122

56

    resetDataLayout("e-m:e-p:32:32-i64:64-n32-S128");

123

56

  }

clang::targets::RISCV32TargetInfo::RISCV32TargetInfo(llvm::Triple const&, clang::TargetOptions const&)

Line

Count

Source

118

41

      : RISCVTargetInfo(Triple, Opts) {

119

41

    IntPtrType = SignedInt;

120

41

    PtrDiffType = SignedInt;

121

41

    SizeType = UnsignedInt;

122

41

    resetDataLayout("e-m:e-p:32:32-i64:64-n32-S128");

123

41

  }

  bool setABI(const std::string &Name) override {

    if (Name == "ilp32" || 
Name == "ilp32f"19
 || 
Name == "ilp32d"13
) {

      ABI = Name;

      return true;

    }

    return false;

  }

  bool isValidCPUName(StringRef Name) const override;

  void fillValidCPUList(SmallVectorImpl<StringRef> &Values) const override;

  bool isValidTuneCPUName(StringRef Name) const override;

  void fillValidTuneCPUList(SmallVectorImpl<StringRef> &Values) const override;

  void setMaxAtomicWidth() override {

    MaxAtomicPromoteWidth = 128;

    if (HasA)

      MaxAtomicInlineWidth = 32;

  }

};

class LLVM_LIBRARY_VISIBILITY RISCV64TargetInfo : public RISCVTargetInfo {

public:

  RISCV64TargetInfo(const llvm::Triple &Triple, const TargetOptions &Opts)

      : RISCVTargetInfo(Triple, Opts) {

    LongWidth = LongAlign = PointerWidth = PointerAlign = 64;

    IntMaxType = Int64Type = SignedLong;

    resetDataLayout("e-m:e-p:64:64-i64:64-i128:128-n64-S128");

  }

clang::targets::RISCV64TargetInfo::RISCV64TargetInfo(llvm::Triple const&, clang::TargetOptions const&)

Line

Count

Source

148

369

      : RISCVTargetInfo(Triple, Opts) {

149

369

    LongWidth = LongAlign = PointerWidth = PointerAlign = 64;

150

369

    IntMaxType = Int64Type = SignedLong;

151

369

    resetDataLayout("e-m:e-p:64:64-i64:64-i128:128-n64-S128");

152

369

  }

clang::targets::RISCV64TargetInfo::RISCV64TargetInfo(llvm::Triple const&, clang::TargetOptions const&)

Line

Count

Source

148

37

      : RISCVTargetInfo(Triple, Opts) {

149

37

    LongWidth = LongAlign = PointerWidth = PointerAlign = 64;

150

37

    IntMaxType = Int64Type = SignedLong;

151

37

    resetDataLayout("e-m:e-p:64:64-i64:64-i128:128-n64-S128");

152

37

  }

  bool setABI(const std::string &Name) override {

    if (Name == "lp64" || 
Name == "lp64f"12
 || 
Name == "lp64d"7
) {

      ABI = Name;

      return true;

    }

    return false;

  }

  bool isValidCPUName(StringRef Name) const override;

  void fillValidCPUList(SmallVectorImpl<StringRef> &Values) const override;

  bool isValidTuneCPUName(StringRef Name) const override;

  void fillValidTuneCPUList(SmallVectorImpl<StringRef> &Values) const override;

  void setMaxAtomicWidth() override {

    MaxAtomicPromoteWidth = 128;

    if (HasA)

      MaxAtomicInlineWidth = 64;

  }

};

} // namespace targets

} // namespace clang

#endif // LLVM_CLANG_LIB_BASIC_TARGETS_RISCV_H