Coverage Report

Created: 2020-09-19 12:23

/Users/buildslave/jenkins/workspace/coverage/llvm-project/clang/lib/Basic/Targets/WebAssembly.h
Line
Count
Source (jump to first uncovered line)
1
//=== WebAssembly.h - Declare WebAssembly 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 WebAssembly TargetInfo objects.
10
//
11
//===----------------------------------------------------------------------===//
12
13
#ifndef LLVM_CLANG_LIB_BASIC_TARGETS_WEBASSEMBLY_H
14
#define LLVM_CLANG_LIB_BASIC_TARGETS_WEBASSEMBLY_H
15
16
#include "clang/Basic/TargetInfo.h"
17
#include "clang/Basic/TargetOptions.h"
18
#include "llvm/ADT/Triple.h"
19
#include "llvm/Support/Compiler.h"
20
21
namespace clang {
22
namespace targets {
23
24
class LLVM_LIBRARY_VISIBILITY WebAssemblyTargetInfo : public TargetInfo {
25
  static const Builtin::Info BuiltinInfo[];
26
27
  enum SIMDEnum {
28
    NoSIMD,
29
    SIMD128,
30
    UnimplementedSIMD128,
31
  } SIMDLevel = NoSIMD;
32
33
  bool HasNontrappingFPToInt = false;
34
  bool HasSignExt = false;
35
  bool HasExceptionHandling = false;
36
  bool HasBulkMemory = false;
37
  bool HasAtomics = false;
38
  bool HasMutableGlobals = false;
39
  bool HasMultivalue = false;
40
  bool HasTailCall = false;
41
  bool HasReferenceTypes = false;
42
43
  std::string ABI;
44
45
public:
46
  explicit WebAssemblyTargetInfo(const llvm::Triple &T, const TargetOptions &)
47
94
      : TargetInfo(T) {
48
94
    NoAsmVariants = true;
49
94
    SuitableAlign = 128;
50
94
    LargeArrayMinWidth = 128;
51
94
    LargeArrayAlign = 128;
52
94
    SimdDefaultAlign = 128;
53
94
    SigAtomicType = SignedLong;
54
94
    LongDoubleWidth = LongDoubleAlign = 128;
55
94
    LongDoubleFormat = &llvm::APFloat::IEEEquad();
56
94
    MaxAtomicPromoteWidth = MaxAtomicInlineWidth = 64;
57
    // size_t being unsigned long for both wasm32 and wasm64 makes mangled names
58
    // more consistent between the two.
59
94
    SizeType = UnsignedLong;
60
94
    PtrDiffType = SignedLong;
61
94
    IntPtrType = SignedLong;
62
94
  }
63
64
  StringRef getABI() const override;
65
  bool setABI(const std::string &Name) override;
66
67
protected:
68
  void getTargetDefines(const LangOptions &Opts,
69
                        MacroBuilder &Builder) const override;
70
71
private:
72
  static void setSIMDLevel(llvm::StringMap<bool> &Features, SIMDEnum Level,
73
                           bool Enabled);
74
75
  bool
76
  initFeatureMap(llvm::StringMap<bool> &Features, DiagnosticsEngine &Diags,
77
                 StringRef CPU,
78
                 const std::vector<std::string> &FeaturesVec) const override;
79
  bool hasFeature(StringRef Feature) const final;
80
81
  void setFeatureEnabled(llvm::StringMap<bool> &Features, StringRef Name,
82
                         bool Enabled) const final;
83
84
  bool handleTargetFeatures(std::vector<std::string> &Features,
85
                            DiagnosticsEngine &Diags) final;
86
87
  bool isValidCPUName(StringRef Name) const final;
88
  void fillValidCPUList(SmallVectorImpl<StringRef> &Values) const final;
89
90
36
  bool setCPU(const std::string &Name) final { return isValidCPUName(Name); }
91
92
  ArrayRef<Builtin::Info> getTargetBuiltins() const final;
93
94
58
  BuiltinVaListKind getBuiltinVaListKind() const final {
95
58
    return VoidPtrBuiltinVaList;
96
58
  }
97
98
0
  ArrayRef<const char *> getGCCRegNames() const final { return None; }
99
100
0
  ArrayRef<TargetInfo::GCCRegAlias> getGCCRegAliases() const final {
101
0
    return None;
102
0
  }
103
104
  bool validateAsmConstraint(const char *&Name,
105
0
                             TargetInfo::ConstraintInfo &Info) const final {
106
0
    return false;
107
0
  }
108
109
0
  const char *getClobbers() const final { return ""; }
110
111
0
  bool isCLZForZeroUndef() const final { return false; }
112
113
272
  bool hasInt128Type() const final { return true; }
114
115
0
  IntType getIntTypeByWidth(unsigned BitWidth, bool IsSigned) const final {
116
    // WebAssembly prefers long long for explicitly 64-bit integers.
117
0
    return BitWidth == 64 ? (IsSigned ? SignedLongLong : UnsignedLongLong)
118
0
                          : TargetInfo::getIntTypeByWidth(BitWidth, IsSigned);
119
0
  }
120
121
1.47k
  IntType getLeastIntTypeByWidth(unsigned BitWidth, bool IsSigned) const final {
122
    // WebAssembly uses long long for int_least64_t and int_fast64_t.
123
1.47k
    return BitWidth == 64
124
368
               ? (IsSigned ? 
SignedLongLong184
:
UnsignedLongLong184
)
125
1.10k
               : TargetInfo::getLeastIntTypeByWidth(BitWidth, IsSigned);
126
1.47k
  }
127
128
0
  CallingConvCheckResult checkCallingConvention(CallingConv CC) const override {
129
0
    switch (CC) {
130
0
    case CC_C:
131
0
    case CC_Swift:
132
0
      return CCCR_OK;
133
0
    default:
134
0
      return CCCR_Warning;
135
0
    }
136
0
  }
137
138
30
  bool hasExtIntType() const override { return true; }
139
140
0
  bool hasProtectedVisibility() const override { return false; }
141
};
142
143
class LLVM_LIBRARY_VISIBILITY WebAssembly32TargetInfo
144
    : public WebAssemblyTargetInfo {
145
public:
146
  explicit WebAssembly32TargetInfo(const llvm::Triple &T,
147
                                   const TargetOptions &Opts)
148
62
      : WebAssemblyTargetInfo(T, Opts) {
149
62
    resetDataLayout("e-m:e-p:32:32-i64:64-n32:64-S128");
150
62
  }
151
152
protected:
153
  void getTargetDefines(const LangOptions &Opts,
154
                        MacroBuilder &Builder) const override;
155
};
156
157
class LLVM_LIBRARY_VISIBILITY WebAssembly64TargetInfo
158
    : public WebAssemblyTargetInfo {
159
public:
160
  explicit WebAssembly64TargetInfo(const llvm::Triple &T,
161
                                   const TargetOptions &Opts)
162
32
      : WebAssemblyTargetInfo(T, Opts) {
163
32
    LongAlign = LongWidth = 64;
164
32
    PointerAlign = PointerWidth = 64;
165
32
    SizeType = UnsignedLong;
166
32
    PtrDiffType = SignedLong;
167
32
    IntPtrType = SignedLong;
168
32
    resetDataLayout("e-m:e-p:64:64-i64:64-n32:64-S128");
169
32
  }
170
171
protected:
172
  void getTargetDefines(const LangOptions &Opts,
173
                        MacroBuilder &Builder) const override;
174
};
175
} // namespace targets
176
} // namespace clang
177
#endif // LLVM_CLANG_LIB_BASIC_TARGETS_WEBASSEMBLY_H