//===--- 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, // 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

53

5

      : TargetInfo(Triple) {

54

5

    TLSSupported = false;

55

5

    IntWidth = 32;

56

5

    LongWidth = LongLongWidth = 32;

57

5

    PointerWidth = 32;

58

5

    IntAlign = 32;

59

5

    LongAlign = LongLongAlign = 32;

60

5

    PointerAlign = 32;

61

5

    SuitableAlign = 32;

62

5

    SizeType = UnsignedInt;

63

5

    IntMaxType = SignedLong;

64

5

    IntPtrType = SignedInt;

65

5

    PtrDiffType = SignedInt;

66

5

    FloatWidth = 32;

67

5

    FloatAlign = 32;

68

5

    DoubleWidth = 32;

69

5

    DoubleAlign = 32;

70

5

    LongDoubleWidth = 32;

71

5

    LongDoubleAlign = 32;

72

5

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

73

5

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

74

5

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

75

5

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

76

5

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

77

5

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

78

5

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

79

5

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

80

5

    AddrSpaceMap = &TCEOpenCLAddrSpaceMap;

81

5

    UseAddrSpaceMapMangling = true;

82

5

  }

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

Line

Count

Source

53

1

      : TargetInfo(Triple) {

54

1

    TLSSupported = false;

55

1

    IntWidth = 32;

56

1

    LongWidth = LongLongWidth = 32;

57

1

    PointerWidth = 32;

58

1

    IntAlign = 32;

59

1

    LongAlign = LongLongAlign = 32;

60

1

    PointerAlign = 32;

61

1

    SuitableAlign = 32;

62

1

    SizeType = UnsignedInt;

63

1

    IntMaxType = SignedLong;

64

1

    IntPtrType = SignedInt;

65

1

    PtrDiffType = SignedInt;

66

1

    FloatWidth = 32;

67

1

    FloatAlign = 32;

68

1

    DoubleWidth = 32;

69

1

    DoubleAlign = 32;

70

1

    LongDoubleWidth = 32;

71

1

    LongDoubleAlign = 32;

72

1

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

73

1

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

74

1

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

75

1

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

76

1

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

77

1

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

78

1

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

79

1

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

80

1

    AddrSpaceMap = &TCEOpenCLAddrSpaceMap;

81

1

    UseAddrSpaceMapMangling = true;

82

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

112

1

      : TCETargetInfo(Triple, Opts) {

113

1

    BigEndian = false;

114

115

1

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

116

1

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

117

1

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

118

1

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

119

1

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

120

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