llvm-project

1
//===- TextStubCommon.cpp -------------------------------------------------===//
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
// Implements common Text Stub YAML mappings.
10
//
11
//===----------------------------------------------------------------------===//
12

13
#include "TextStubCommon.h"
14
#include "TextAPIContext.h"
15
#include "llvm/ADT/StringSwitch.h"
16

17
using namespace llvm::MachO;
18

19
namespace llvm {
20
namespace yaml {
21

22
void ScalarTraits<FlowStringRef>::output(const FlowStringRef &Value, void *Ctx,
23
                                         raw_ostream &OS) {
24
  ScalarTraits<StringRef>::output(Value, Ctx, OS);
25
}
26
StringRef ScalarTraits<FlowStringRef>::input(StringRef Value, void *Ctx,
27
                                             FlowStringRef &Out) {
28
  return ScalarTraits<StringRef>::input(Value, Ctx, Out.value);
29
}
30
QuotingType ScalarTraits<FlowStringRef>::mustQuote(StringRef Name) {
31
  return ScalarTraits<StringRef>::mustQuote(Name);
32
}
33

34
void ScalarEnumerationTraits<ObjCConstraintType>::enumeration(
35
    IO &IO, ObjCConstraintType &Constraint) {
36
  IO.enumCase(Constraint, "none", ObjCConstraintType::None);
37
  IO.enumCase(Constraint, "retain_release", ObjCConstraintType::Retain_Release);
38
  IO.enumCase(Constraint, "retain_release_for_simulator",
39
              ObjCConstraintType::Retain_Release_For_Simulator);
40
  IO.enumCase(Constraint, "retain_release_or_gc",
41
              ObjCConstraintType::Retain_Release_Or_GC);
42
  IO.enumCase(Constraint, "gc", ObjCConstraintType::GC);
43
}
44

45
void ScalarTraits<PlatformSet>::output(const PlatformSet &Values, void *IO,
46
                                       raw_ostream &OS) {
47

48
  const auto *Ctx = reinterpret_cast<TextAPIContext *>(IO);
49
  assert((!Ctx || Ctx->FileKind != FileType::Invalid) &&
50
         "File type is not set in context");
51

52
  if (Ctx && Ctx->FileKind == TBD_V3 && Values.count(PLATFORM_MACOS) &&
53
      Values.count(PLATFORM_MACCATALYST)) {
54
    OS << "zippered";
55
    return;
56
  }
57

58
  assert(Values.size() == 1U);
59
  switch (*Values.begin()) {
60
  default:
61
    llvm_unreachable("unexpected platform");
62
    break;
63
  case PLATFORM_MACOS:
64
    OS << "macosx";
65
    break;
66
  case PLATFORM_IOSSIMULATOR:
67
    [[fallthrough]];
68
  case PLATFORM_IOS:
69
    OS << "ios";
70
    break;
71
  case PLATFORM_WATCHOSSIMULATOR:
72
    [[fallthrough]];
73
  case PLATFORM_WATCHOS:
74
    OS << "watchos";
75
    break;
76
  case PLATFORM_TVOSSIMULATOR:
77
    [[fallthrough]];
78
  case PLATFORM_TVOS:
79
    OS << "tvos";
80
    break;
81
  case PLATFORM_BRIDGEOS:
82
    OS << "bridgeos";
83
    break;
84
  case PLATFORM_MACCATALYST:
85
    OS << "maccatalyst";
86
    break;
87
  case PLATFORM_DRIVERKIT:
88
    OS << "driverkit";
89
    break;
90
  }
91
}
92

93
StringRef ScalarTraits<PlatformSet>::input(StringRef Scalar, void *IO,
94
                                           PlatformSet &Values) {
95
  const auto *Ctx = reinterpret_cast<TextAPIContext *>(IO);
96
  assert((!Ctx || Ctx->FileKind != FileType::Invalid) &&
97
         "File type is not set in context");
98

99
  if (Scalar == "zippered") {
100
    if (Ctx && Ctx->FileKind == FileType::TBD_V3) {
101
      Values.insert(PLATFORM_MACOS);
102
      Values.insert(PLATFORM_MACCATALYST);
103
      return {};
104
    }
105
    return "invalid platform";
106
  }
107

108
  auto Platform = StringSwitch<PlatformType>(Scalar)
109
                      .Case("macosx", PLATFORM_MACOS)
110
                      .Case("ios", PLATFORM_IOS)
111
                      .Case("watchos", PLATFORM_WATCHOS)
112
                      .Case("tvos", PLATFORM_TVOS)
113
                      .Case("bridgeos", PLATFORM_BRIDGEOS)
114
                      .Case("iosmac", PLATFORM_MACCATALYST)
115
                      .Case("maccatalyst", PLATFORM_MACCATALYST)
116
                      .Case("driverkit", PLATFORM_DRIVERKIT)
117
                      .Default(PLATFORM_UNKNOWN);
118

119
  if (Platform == PLATFORM_MACCATALYST)
120
    if (Ctx && Ctx->FileKind != FileType::TBD_V3)
121
      return "invalid platform";
122

123
  if (Platform == PLATFORM_UNKNOWN)
124
    return "unknown platform";
125

126
  Values.insert(Platform);
127
  return {};
128
}
129

130
QuotingType ScalarTraits<PlatformSet>::mustQuote(StringRef) {
131
  return QuotingType::None;
132
}
133

134
void ScalarBitSetTraits<ArchitectureSet>::bitset(IO &IO,
135
                                                 ArchitectureSet &Archs) {
136
#define ARCHINFO(arch, type, subtype, numbits)                                 \
137
  IO.bitSetCase(Archs, #arch, 1U << static_cast<int>(AK_##arch));
138
#include "llvm/TextAPI/Architecture.def"
139
#undef ARCHINFO
140
}
141

142
void ScalarTraits<Architecture>::output(const Architecture &Value, void *,
143
                                        raw_ostream &OS) {
144
  OS << Value;
145
}
146
StringRef ScalarTraits<Architecture>::input(StringRef Scalar, void *,
147
                                            Architecture &Value) {
148
  Value = getArchitectureFromName(Scalar);
149
  return {};
150
}
151
QuotingType ScalarTraits<Architecture>::mustQuote(StringRef) {
152
  return QuotingType::None;
153
}
154

155
void ScalarTraits<PackedVersion>::output(const PackedVersion &Value, void *,
156
                                         raw_ostream &OS) {
157
  OS << Value;
158
}
159
StringRef ScalarTraits<PackedVersion>::input(StringRef Scalar, void *,
160
                                             PackedVersion &Value) {
161
  if (!Value.parse32(Scalar))
162
    return "invalid packed version string.";
163
  return {};
164
}
165
QuotingType ScalarTraits<PackedVersion>::mustQuote(StringRef) {
166
  return QuotingType::None;
167
}
168

169
void ScalarTraits<SwiftVersion>::output(const SwiftVersion &Value, void *,
170
                                        raw_ostream &OS) {
171
  switch (Value) {
172
  case 1:
173
    OS << "1.0";
174
    break;
175
  case 2:
176
    OS << "1.1";
177
    break;
178
  case 3:
179
    OS << "2.0";
180
    break;
181
  case 4:
182
    OS << "3.0";
183
    break;
184
  default:
185
    OS << (unsigned)Value;
186
    break;
187
  }
188
}
189
StringRef ScalarTraits<SwiftVersion>::input(StringRef Scalar, void *IO,
190
                                            SwiftVersion &Value) {
191
  const auto *Ctx = reinterpret_cast<TextAPIContext *>(IO);
192
  assert((!Ctx || Ctx->FileKind != FileType::Invalid) &&
193
         "File type is not set in context");
194

195
  if (Ctx->FileKind == FileType::TBD_V4) {
196
    if (Scalar.getAsInteger(10, Value))
197
      return "invalid Swift ABI version.";
198
    return {};
199
  } else {
200
    Value = StringSwitch<SwiftVersion>(Scalar)
201
                .Case("1.0", 1)
202
                .Case("1.1", 2)
203
                .Case("2.0", 3)
204
                .Case("3.0", 4)
205
                .Default(0);
206
  }
207

208
  if (Value != SwiftVersion(0))
209
    return {};
210

211
  if (Scalar.getAsInteger(10, Value))
212
    return "invalid Swift ABI version.";
213

214
  return StringRef();
215
}
216
QuotingType ScalarTraits<SwiftVersion>::mustQuote(StringRef) {
217
  return QuotingType::None;
218
}
219

220
void ScalarTraits<UUID>::output(const UUID &Value, void *, raw_ostream &OS) {}
221

222
StringRef ScalarTraits<UUID>::input(StringRef Scalar, void *, UUID &Value) {
223
  Value = {};
224
  return {};
225
}
226

227
QuotingType ScalarTraits<UUID>::mustQuote(StringRef) {
228
  return QuotingType::Single;
229
}
230

231
} // end namespace yaml.
232
} // end namespace llvm.
233