Coverage Report

Created: 2020-09-19 12:23

/Users/buildslave/jenkins/workspace/coverage/llvm-project/clang/lib/Basic/Targets/Hexagon.h
Line
Count
Source (jump to first uncovered line)
1
//===--- Hexagon.h - Declare Hexagon 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 Hexagon TargetInfo objects.
10
//
11
//===----------------------------------------------------------------------===//
12
13
#ifndef LLVM_CLANG_LIB_BASIC_TARGETS_HEXAGON_H
14
#define LLVM_CLANG_LIB_BASIC_TARGETS_HEXAGON_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
// Hexagon abstract base class
25
class LLVM_LIBRARY_VISIBILITY HexagonTargetInfo : public TargetInfo {
26
27
  static const Builtin::Info BuiltinInfo[];
28
  static const char *const GCCRegNames[];
29
  static const TargetInfo::GCCRegAlias GCCRegAliases[];
30
  std::string CPU;
31
  std::string HVXVersion;
32
  bool HasHVX = false;
33
  bool HasHVX64B = false;
34
  bool HasHVX128B = false;
35
  bool HasAudio = false;
36
  bool UseLongCalls = false;
37
38
public:
39
  HexagonTargetInfo(const llvm::Triple &Triple, const TargetOptions &)
40
60
      : TargetInfo(Triple) {
41
    // Specify the vector alignment explicitly. For v512x1, the calculated
42
    // alignment would be 512*alignment(i1), which is 512 bytes, instead of
43
    // the required minimum of 64 bytes.
44
60
    resetDataLayout(
45
60
        "e-m:e-p:32:32:32-a:0-n16:32-"
46
60
        "i64:64:64-i32:32:32-i16:16:16-i1:8:8-f32:32:32-f64:64:64-"
47
60
        "v32:32:32-v64:64:64-v512:512:512-v1024:1024:1024-v2048:2048:2048");
48
60
    SizeType = UnsignedInt;
49
60
    PtrDiffType = SignedInt;
50
60
    IntPtrType = SignedInt;
51
60
52
    // {} in inline assembly are packet specifiers, not assembly variant
53
    // specifiers.
54
60
    NoAsmVariants = true;
55
60
56
60
    LargeArrayMinWidth = 64;
57
60
    LargeArrayAlign = 64;
58
60
    UseBitFieldTypeAlignment = true;
59
60
    ZeroLengthBitfieldBoundary = 32;
60
60
    MaxAtomicPromoteWidth = MaxAtomicInlineWidth = 64;
61
60
62
    // These are the default values anyway, but explicitly make sure
63
    // that the size of the boolean type is 8 bits. Bool vectors are used
64
    // for modeling predicate registers in HVX, and the bool -> byte
65
    // correspondence matches the HVX architecture.
66
60
    BoolWidth = BoolAlign = 8;
67
60
  }
clang::targets::HexagonTargetInfo::HexagonTargetInfo(llvm::Triple const&, clang::TargetOptions const&)
Line
Count
Source
40
57
      : TargetInfo(Triple) {
41
    // Specify the vector alignment explicitly. For v512x1, the calculated
42
    // alignment would be 512*alignment(i1), which is 512 bytes, instead of
43
    // the required minimum of 64 bytes.
44
57
    resetDataLayout(
45
57
        "e-m:e-p:32:32:32-a:0-n16:32-"
46
57
        "i64:64:64-i32:32:32-i16:16:16-i1:8:8-f32:32:32-f64:64:64-"
47
57
        "v32:32:32-v64:64:64-v512:512:512-v1024:1024:1024-v2048:2048:2048");
48
57
    SizeType = UnsignedInt;
49
57
    PtrDiffType = SignedInt;
50
57
    IntPtrType = SignedInt;
51
57
52
    // {} in inline assembly are packet specifiers, not assembly variant
53
    // specifiers.
54
57
    NoAsmVariants = true;
55
57
56
57
    LargeArrayMinWidth = 64;
57
57
    LargeArrayAlign = 64;
58
57
    UseBitFieldTypeAlignment = true;
59
57
    ZeroLengthBitfieldBoundary = 32;
60
57
    MaxAtomicPromoteWidth = MaxAtomicInlineWidth = 64;
61
57
62
    // These are the default values anyway, but explicitly make sure
63
    // that the size of the boolean type is 8 bits. Bool vectors are used
64
    // for modeling predicate registers in HVX, and the bool -> byte
65
    // correspondence matches the HVX architecture.
66
57
    BoolWidth = BoolAlign = 8;
67
57
  }
clang::targets::HexagonTargetInfo::HexagonTargetInfo(llvm::Triple const&, clang::TargetOptions const&)
Line
Count
Source
40
3
      : TargetInfo(Triple) {
41
    // Specify the vector alignment explicitly. For v512x1, the calculated
42
    // alignment would be 512*alignment(i1), which is 512 bytes, instead of
43
    // the required minimum of 64 bytes.
44
3
    resetDataLayout(
45
3
        "e-m:e-p:32:32:32-a:0-n16:32-"
46
3
        "i64:64:64-i32:32:32-i16:16:16-i1:8:8-f32:32:32-f64:64:64-"
47
3
        "v32:32:32-v64:64:64-v512:512:512-v1024:1024:1024-v2048:2048:2048");
48
3
    SizeType = UnsignedInt;
49
3
    PtrDiffType = SignedInt;
50
3
    IntPtrType = SignedInt;
51
3
52
    // {} in inline assembly are packet specifiers, not assembly variant
53
    // specifiers.
54
3
    NoAsmVariants = true;
55
3
56
3
    LargeArrayMinWidth = 64;
57
3
    LargeArrayAlign = 64;
58
3
    UseBitFieldTypeAlignment = true;
59
3
    ZeroLengthBitfieldBoundary = 32;
60
3
    MaxAtomicPromoteWidth = MaxAtomicInlineWidth = 64;
61
3
62
    // These are the default values anyway, but explicitly make sure
63
    // that the size of the boolean type is 8 bits. Bool vectors are used
64
    // for modeling predicate registers in HVX, and the bool -> byte
65
    // correspondence matches the HVX architecture.
66
3
    BoolWidth = BoolAlign = 8;
67
3
  }
68
69
  ArrayRef<Builtin::Info> getTargetBuiltins() const override;
70
71
  bool validateAsmConstraint(const char *&Name,
72
10
                             TargetInfo::ConstraintInfo &Info) const override {
73
10
    switch (*Name) {
74
6
    case 'v':
75
6
    case 'q':
76
6
      if (HasHVX) {
77
6
        Info.setAllowsRegister();
78
6
        return true;
79
6
      }
80
0
      break;
81
2
    case 'a': // Modifier register m0-m1.
82
2
      Info.setAllowsRegister();
83
2
      return true;
84
2
    case 's':
85
      // Relocatable constant.
86
2
      return true;
87
0
    }
88
0
    return false;
89
0
  }
90
91
  void getTargetDefines(const LangOptions &Opts,
92
                        MacroBuilder &Builder) const override;
93
94
0
  bool isCLZForZeroUndef() const override { return false; }
95
96
  bool hasFeature(StringRef Feature) const override;
97
98
  bool
99
  initFeatureMap(llvm::StringMap<bool> &Features, DiagnosticsEngine &Diags,
100
                 StringRef CPU,
101
                 const std::vector<std::string> &FeaturesVec) const override;
102
103
  bool handleTargetFeatures(std::vector<std::string> &Features,
104
                            DiagnosticsEngine &Diags) override;
105
106
45
  BuiltinVaListKind getBuiltinVaListKind() const override {
107
45
    if (getTriple().isMusl())
108
1
      return TargetInfo::HexagonBuiltinVaList;
109
44
    return TargetInfo::CharPtrBuiltinVaList;
110
44
  }
111
112
  ArrayRef<const char *> getGCCRegNames() const override;
113
114
  ArrayRef<TargetInfo::GCCRegAlias> getGCCRegAliases() const override;
115
116
3
  const char *getClobbers() const override { return ""; }
117
118
  static const char *getHexagonCPUSuffix(StringRef Name);
119
120
48
  bool isValidCPUName(StringRef Name) const override {
121
48
    return getHexagonCPUSuffix(Name);
122
48
  }
123
124
  void fillValidCPUList(SmallVectorImpl<StringRef> &Values) const override;
125
126
48
  bool setCPU(const std::string &Name) override {
127
48
    if (!isValidCPUName(Name))
128
1
      return false;
129
47
    CPU = Name;
130
47
    return true;
131
47
  }
132
133
0
  int getEHDataRegisterNumber(unsigned RegNo) const override {
134
0
    return RegNo < 2 ? RegNo : -1;
135
0
  }
136
137
118
  bool isTinyCore() const {
138
    // We can write more stricter checks later.
139
118
    return CPU.find('t') != std::string::npos;
140
118
  }
141
142
15
  bool hasExtIntType() const override { return true; }
143
};
144
} // namespace targets
145
} // namespace clang
146
#endif // LLVM_CLANG_LIB_BASIC_TARGETS_HEXAGON_H