//===--- TCE.h - Declare TCE 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 TCE TargetInfo objects.

//

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

#ifndef LLVM_CLANG_LIB_BASIC_TARGETS_TCE_H

#define LLVM_CLANG_LIB_BASIC_TARGETS_TCE_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 {

// llvm and clang cannot be used directly to output native binaries for

// target, but is used to compile C code to llvm bitcode with correct

// type and alignment information.

//

// TCE uses the llvm bitcode as input and uses it for generating customized

// target processor and program binary. TCE co-design environment is

// publicly available in http://tce.cs.tut.fi

static const unsigned TCEOpenCLAddrSpaceMap[] = {

    0, // Default

    3, // opencl_global

    4, // opencl_local

    5, // opencl_constant

    0, // opencl_private

    1, // opencl_global_device

    1, // opencl_global_host

    // FIXME: generic has to be added to the target

    0, // opencl_generic

    0, // cuda_device

    0, // cuda_constant

    0, // cuda_shared

    0, // sycl_global

    0, // sycl_global_device

    0, // sycl_global_host

    0, // sycl_local

    0, // sycl_private

    0, // ptr32_sptr

    0, // ptr32_uptr

    0, // ptr64

};

class LLVM_LIBRARY_VISIBILITY TCETargetInfo : public TargetInfo {

public:

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

      : TargetInfo(Triple) {

    TLSSupported = false;

    IntWidth = 32;

    LongWidth = LongLongWidth = 32;

    PointerWidth = 32;

    IntAlign = 32;

    LongAlign = LongLongAlign = 32;

    PointerAlign = 32;

    SuitableAlign = 32;

    SizeType = UnsignedInt;

    IntMaxType = SignedLong;

    IntPtrType = SignedInt;

    PtrDiffType = SignedInt;

    FloatWidth = 32;

    FloatAlign = 32;

    DoubleWidth = 32;

    DoubleAlign = 32;

    LongDoubleWidth = 32;

    LongDoubleAlign = 32;

    FloatFormat = &llvm::APFloat::IEEEsingle();

    DoubleFormat = &llvm::APFloat::IEEEsingle();

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

    resetDataLayout("E-p:32:32:32-i1:8:8-i8:8:32-"

                    "i16:16:32-i32:32:32-i64:32:32-"

                    "f32:32:32-f64:32:32-v64:32:32-"

                    "v128:32:32-v256:32:32-v512:32:32-"

                    "v1024:32:32-a0:0:32-n32");

    AddrSpaceMap = &TCEOpenCLAddrSpaceMap;

    UseAddrSpaceMapMangling = true;

  }

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

Line

Count

Source

58

6

      : TargetInfo(Triple) {

59

6

    TLSSupported = false;

60

6

    IntWidth = 32;

61

6

    LongWidth = LongLongWidth = 32;

62

6

    PointerWidth = 32;

63

6

    IntAlign = 32;

64

6

    LongAlign = LongLongAlign = 32;

65

6

    PointerAlign = 32;

66

6

    SuitableAlign = 32;

67

6

    SizeType = UnsignedInt;

68

6

    IntMaxType = SignedLong;

69

6

    IntPtrType = SignedInt;

70

6

    PtrDiffType = SignedInt;

71

6

    FloatWidth = 32;

72

6

    FloatAlign = 32;

73

6

    DoubleWidth = 32;

74

6

    DoubleAlign = 32;

75

6

    LongDoubleWidth = 32;

76

6

    LongDoubleAlign = 32;

77

6

    FloatFormat = &llvm::APFloat::IEEEsingle();

78

6

    DoubleFormat = &llvm::APFloat::IEEEsingle();

79

6

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

80

6

    resetDataLayout("E-p:32:32:32-i1:8:8-i8:8:32-"

81

6

                    "i16:16:32-i32:32:32-i64:32:32-"

82

6

                    "f32:32:32-f64:32:32-v64:32:32-"

83

6

                    "v128:32:32-v256:32:32-v512:32:32-"

84

6

                    "v1024:32:32-a0:0:32-n32");

85

6

    AddrSpaceMap = &TCEOpenCLAddrSpaceMap;

86

6

    UseAddrSpaceMapMangling = true;

87

6

  }

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

Line

Count

Source

58

1

      : TargetInfo(Triple) {

59

1

    TLSSupported = false;

60

1

    IntWidth = 32;

61

1

    LongWidth = LongLongWidth = 32;

62

1

    PointerWidth = 32;

63

1

    IntAlign = 32;

64

1

    LongAlign = LongLongAlign = 32;

65

1

    PointerAlign = 32;

66

1

    SuitableAlign = 32;

67

1

    SizeType = UnsignedInt;

68

1

    IntMaxType = SignedLong;

69

1

    IntPtrType = SignedInt;

70

1

    PtrDiffType = SignedInt;

71

1

    FloatWidth = 32;

72

1

    FloatAlign = 32;

73

1

    DoubleWidth = 32;

74

1

    DoubleAlign = 32;

75

1

    LongDoubleWidth = 32;

76

1

    LongDoubleAlign = 32;

77

1

    FloatFormat = &llvm::APFloat::IEEEsingle();

78

1

    DoubleFormat = &llvm::APFloat::IEEEsingle();

79

1

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

80

1

    resetDataLayout("E-p:32:32:32-i1:8:8-i8:8:32-"

81

1

                    "i16:16:32-i32:32:32-i64:32:32-"

82

1

                    "f32:32:32-f64:32:32-v64:32:32-"

83

1

                    "v128:32:32-v256:32:32-v512:32:32-"

84

1

                    "v1024:32:32-a0:0:32-n32");

85

1

    AddrSpaceMap = &TCEOpenCLAddrSpaceMap;

86

1

    UseAddrSpaceMapMangling = true;

87

1

  }

  void getTargetDefines(const LangOptions &Opts,

                        MacroBuilder &Builder) const override;

  bool hasFeature(StringRef Feature) const override { return Feature == "tce"; }

  ArrayRef<Builtin::Info> getTargetBuiltins() const override { return None; }

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

  BuiltinVaListKind getBuiltinVaListKind() const override {

    return TargetInfo::VoidPtrBuiltinVaList;

  }

  ArrayRef<const char *> getGCCRegNames() const override { return None; }

  bool validateAsmConstraint(const char *&Name,

                             TargetInfo::ConstraintInfo &info) const override {

    return true;

  }

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

    return None;

  }

};

class LLVM_LIBRARY_VISIBILITY TCELETargetInfo : public TCETargetInfo {

public:

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

      : TCETargetInfo(Triple, Opts) {

    BigEndian = false;

    resetDataLayout("e-p:32:32:32-i1:8:8-i8:8:32-"

                    "i16:16:32-i32:32:32-i64:32:32-"

                    "f32:32:32-f64:32:32-v64:32:32-"

                    "v128:32:32-v256:32:32-v512:32:32-"

                    "v1024:32:32-a0:0:32-n32");

  }

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

Line

Count

Source

117

1

      : TCETargetInfo(Triple, Opts) {

118

1

    BigEndian = false;

119

120

1

    resetDataLayout("e-p:32:32:32-i1:8:8-i8:8:32-"

121

1

                    "i16:16:32-i32:32:32-i64:32:32-"

122

1

                    "f32:32:32-f64:32:32-v64:32:32-"

123

1

                    "v128:32:32-v256:32:32-v512:32:32-"

124

1

                    "v1024:32:32-a0:0:32-n32");

125

1

  }

Unexecuted instantiation: clang::targets::TCELETargetInfo::TCELETargetInfo(llvm::Triple const&, clang::TargetOptions const&)

  void getTargetDefines(const LangOptions &Opts,

                        MacroBuilder &Builder) const override;

};

} // namespace targets

} // namespace clang

#endif // LLVM_CLANG_LIB_BASIC_TARGETS_TCE_H