contrib/llvm/tools/clang/lib/Basic/Targets/WebAssembly.h

   1 //=== WebAssembly.h - Declare WebAssembly target feature support *- C++ -*-===//
   2 //
   3 //                     The LLVM Compiler Infrastructure
   4 //
   5 // This file is distributed under the University of Illinois Open Source
   6 // License. See LICENSE.TXT for details.
   7 //
   8 //===----------------------------------------------------------------------===//
   9 //
  10 // This file declares WebAssembly TargetInfo objects.
  11 //
  12 //===----------------------------------------------------------------------===//
  13
  14 #ifndef LLVM_CLANG_LIB_BASIC_TARGETS_WEBASSEMBLY_H
  15 #define LLVM_CLANG_LIB_BASIC_TARGETS_WEBASSEMBLY_H
  16
  17 #include "clang/Basic/TargetInfo.h"
  18 #include "clang/Basic/TargetOptions.h"
  19 #include "llvm/ADT/Triple.h"
  20 #include "llvm/Support/Compiler.h"
  21
  22 namespace clang {
  23 namespace targets {
  24
  25 class LLVM_LIBRARY_VISIBILITY WebAssemblyTargetInfo : public TargetInfo {
  26   static const Builtin::Info BuiltinInfo[];
  27
  28   enum SIMDEnum {
  29     NoSIMD,
  30     SIMD128,
  31   } SIMDLevel;
  32
  33   bool HasNontrappingFPToInt;
  34   bool HasSignExt;
  35   bool HasExceptionHandling;
  36
  37 public:
  38   explicit WebAssemblyTargetInfo(const llvm::Triple &T, const TargetOptions &)
  39       : TargetInfo(T), SIMDLevel(NoSIMD), HasNontrappingFPToInt(false),
  40         HasSignExt(false), HasExceptionHandling(false) {
  41     NoAsmVariants = true;
  42     SuitableAlign = 128;
  43     LargeArrayMinWidth = 128;
  44     LargeArrayAlign = 128;
  45     SimdDefaultAlign = 128;
  46     SigAtomicType = SignedLong;
  47     LongDoubleWidth = LongDoubleAlign = 128;
  48     LongDoubleFormat = &llvm::APFloat::IEEEquad();
  49     MaxAtomicPromoteWidth = MaxAtomicInlineWidth = 64;
  50     // size_t being unsigned long for both wasm32 and wasm64 makes mangled names
  51     // more consistent between the two.
  52     SizeType = UnsignedLong;
  53     PtrDiffType = SignedLong;
  54     IntPtrType = SignedLong;
  55   }
  56
  57 protected:
  58   void getTargetDefines(const LangOptions &Opts,
  59                         MacroBuilder &Builder) const override;
  60
  61 private:
  62   bool
  63   initFeatureMap(llvm::StringMap<bool> &Features, DiagnosticsEngine &Diags,
  64                  StringRef CPU,
  65                  const std::vector<std::string> &FeaturesVec) const override {
  66     if (CPU == "bleeding-edge") {
  67       Features["simd128"] = true;
  68       Features["nontrapping-fptoint"] = true;
  69       Features["sign-ext"] = true;
  70     }
  71     return TargetInfo::initFeatureMap(Features, Diags, CPU, FeaturesVec);
  72   }
  73
  74   bool hasFeature(StringRef Feature) const final;
  75
  76   bool handleTargetFeatures(std::vector<std::string> &Features,
  77                             DiagnosticsEngine &Diags) final;
  78
  79   bool isValidCPUName(StringRef Name) const final;
  80   void fillValidCPUList(SmallVectorImpl<StringRef> &Values) const final;
  81
  82   bool setCPU(const std::string &Name) final { return isValidCPUName(Name); }
  83
  84   ArrayRef<Builtin::Info> getTargetBuiltins() const final;
  85
  86   BuiltinVaListKind getBuiltinVaListKind() const final {
  87     return VoidPtrBuiltinVaList;
  88   }
  89
  90   ArrayRef<const char *> getGCCRegNames() const final { return None; }
  91
  92   ArrayRef<TargetInfo::GCCRegAlias> getGCCRegAliases() const final {
  93     return None;
  94   }
  95
  96   bool validateAsmConstraint(const char *&Name,
  97                              TargetInfo::ConstraintInfo &Info) const final {
  98     return false;
  99   }
 100
 101   const char *getClobbers() const final { return ""; }
 102
 103   bool isCLZForZeroUndef() const final { return false; }
 104
 105   bool hasInt128Type() const final { return true; }
 106
 107   IntType getIntTypeByWidth(unsigned BitWidth, bool IsSigned) const final {
 108     // WebAssembly prefers long long for explicitly 64-bit integers.
 109     return BitWidth == 64 ? (IsSigned ? SignedLongLong : UnsignedLongLong)
 110                           : TargetInfo::getIntTypeByWidth(BitWidth, IsSigned);
 111   }
 112
 113   IntType getLeastIntTypeByWidth(unsigned BitWidth, bool IsSigned) const final {
 114     // WebAssembly uses long long for int_least64_t and int_fast64_t.
 115     return BitWidth == 64
 116                ? (IsSigned ? SignedLongLong : UnsignedLongLong)
 117                : TargetInfo::getLeastIntTypeByWidth(BitWidth, IsSigned);
 118   }
 119 };
 120 class LLVM_LIBRARY_VISIBILITY WebAssembly32TargetInfo
 121     : public WebAssemblyTargetInfo {
 122 public:
 123   explicit WebAssembly32TargetInfo(const llvm::Triple &T,
 124                                    const TargetOptions &Opts)
 125       : WebAssemblyTargetInfo(T, Opts) {
 126     resetDataLayout("e-m:e-p:32:32-i64:64-n32:64-S128");
 127   }
 128
 129 protected:
 130   void getTargetDefines(const LangOptions &Opts,
 131                         MacroBuilder &Builder) const override;
 132 };
 133
 134 class LLVM_LIBRARY_VISIBILITY WebAssembly64TargetInfo
 135     : public WebAssemblyTargetInfo {
 136 public:
 137   explicit WebAssembly64TargetInfo(const llvm::Triple &T,
 138                                    const TargetOptions &Opts)
 139       : WebAssemblyTargetInfo(T, Opts) {
 140     LongAlign = LongWidth = 64;
 141     PointerAlign = PointerWidth = 64;
 142     SizeType = UnsignedLong;
 143     PtrDiffType = SignedLong;
 144     IntPtrType = SignedLong;
 145     resetDataLayout("e-m:e-p:64:64-i64:64-n32:64-S128");
 146   }
 147
 148 protected:
 149   void getTargetDefines(const LangOptions &Opts,
 150                         MacroBuilder &Builder) const override;
 151 };
 152 } // namespace targets
 153 } // namespace clang
 154 #endif // LLVM_CLANG_LIB_BASIC_TARGETS_WEBASSEMBLY_H