clang/lib/Basic/Targets/TCE.h

   1 //===--- TCE.h - Declare TCE target feature support -------------*- C++ -*-===//
   2 //
   3 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
   4 // See https://llvm.org/LICENSE.txt for license information.
   5 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
   6 //
   7 //===----------------------------------------------------------------------===//
   8 //
   9 // This file declares TCE TargetInfo objects.
  10 //
  11 //===----------------------------------------------------------------------===//
  12
  13 #ifndef LLVM_CLANG_LIB_BASIC_TARGETS_TCE_H
  14 #define LLVM_CLANG_LIB_BASIC_TARGETS_TCE_H
  15
  16 #include "clang/Basic/TargetInfo.h"
  17 #include "clang/Basic/TargetOptions.h"
  18 #include "llvm/Support/Compiler.h"
  19 #include "llvm/TargetParser/Triple.h"
  20
  21 namespace clang {
  22 namespace targets {
  23
  24 // llvm and clang cannot be used directly to output native binaries for
  25 // target, but is used to compile C code to llvm bitcode with correct
  26 // type and alignment information.
  27 //
  28 // TCE uses the llvm bitcode as input and uses it for generating customized
  29 // target processor and program binary. TCE co-design environment is
  30 // publicly available in http://tce.cs.tut.fi
  31
  32 static const unsigned TCEOpenCLAddrSpaceMap[] = {
  33     0, // Default
  34     3, // opencl_global
  35     4, // opencl_local
  36     5, // opencl_constant
  37     0, // opencl_private
  38     1, // opencl_global_device
  39     1, // opencl_global_host
  40     // FIXME: generic has to be added to the target
  41     0, // opencl_generic
  42     0, // cuda_device
  43     0, // cuda_constant
  44     0, // cuda_shared
  45     0, // sycl_global
  46     0, // sycl_global_device
  47     0, // sycl_global_host
  48     0, // sycl_local
  49     0, // sycl_private
  50     0, // ptr32_sptr
  51     0, // ptr32_uptr
  52     0, // ptr64
  53     0, // hlsl_groupshared
  54 };
  55
  56 class LLVM_LIBRARY_VISIBILITY TCETargetInfo : public TargetInfo {
  57 public:
  58   TCETargetInfo(const llvm::Triple &Triple, const TargetOptions &)
  59       : TargetInfo(Triple) {
  60     TLSSupported = false;
  61     IntWidth = 32;
  62     LongWidth = LongLongWidth = 32;
  63     PointerWidth = 32;
  64     IntAlign = 32;
  65     LongAlign = LongLongAlign = 32;
  66     PointerAlign = 32;
  67     SuitableAlign = 32;
  68     SizeType = UnsignedInt;
  69     IntMaxType = SignedLong;
  70     IntPtrType = SignedInt;
  71     PtrDiffType = SignedInt;
  72     FloatWidth = 32;
  73     FloatAlign = 32;
  74     DoubleWidth = 32;
  75     DoubleAlign = 32;
  76     LongDoubleWidth = 32;
  77     LongDoubleAlign = 32;
  78     FloatFormat = &llvm::APFloat::IEEEsingle();
  79     DoubleFormat = &llvm::APFloat::IEEEsingle();
  80     LongDoubleFormat = &llvm::APFloat::IEEEsingle();
  81     resetDataLayout("E-p:32:32:32-i1:8:8-i8:8:32-"
  82                     "i16:16:32-i32:32:32-i64:32:32-"
  83                     "f32:32:32-f64:32:32-v64:32:32-"
  84                     "v128:32:32-v256:32:32-v512:32:32-"
  85                     "v1024:32:32-a0:0:32-n32");
  86     AddrSpaceMap = &TCEOpenCLAddrSpaceMap;
  87     UseAddrSpaceMapMangling = true;
  88   }
  89
  90   void getTargetDefines(const LangOptions &Opts,
  91                         MacroBuilder &Builder) const override;
  92
  93   bool hasFeature(StringRef Feature) const override { return Feature == "tce"; }
  94
  95   ArrayRef<Builtin::Info> getTargetBuiltins() const override {
  96     return std::nullopt;
  97   }
  98
  99   const char *getClobbers() const override { return ""; }
 100
 101   BuiltinVaListKind getBuiltinVaListKind() const override {
 102     return TargetInfo::VoidPtrBuiltinVaList;
 103   }
 104
 105   ArrayRef<const char *> getGCCRegNames() const override {
 106     return std::nullopt;
 107   }
 108
 109   bool validateAsmConstraint(const char *&Name,
 110                              TargetInfo::ConstraintInfo &info) const override {
 111     return true;
 112   }
 113
 114   ArrayRef<TargetInfo::GCCRegAlias> getGCCRegAliases() const override {
 115     return std::nullopt;
 116   }
 117 };
 118
 119 class LLVM_LIBRARY_VISIBILITY TCELETargetInfo : public TCETargetInfo {
 120 public:
 121   TCELETargetInfo(const llvm::Triple &Triple, const TargetOptions &Opts)
 122       : TCETargetInfo(Triple, Opts) {
 123     BigEndian = false;
 124
 125     resetDataLayout("e-p:32:32:32-i1:8:8-i8:8:32-"
 126                     "i16:16:32-i32:32:32-i64:32:32-"
 127                     "f32:32:32-f64:32:32-v64:32:32-"
 128                     "v128:32:32-v256:32:32-v512:32:32-"
 129                     "v1024:32:32-a0:0:32-n32");
 130   }
 131
 132   void getTargetDefines(const LangOptions &Opts,
 133                         MacroBuilder &Builder) const override;
 134 };
 135 } // namespace targets
 136 } // namespace clang
 137 #endif // LLVM_CLANG_LIB_BASIC_TARGETS_TCE_H