Coverage Report

Created: 2018-09-17 19:50

/Users/buildslave/jenkins/workspace/clang-stage2-coverage-R/llvm/include/llvm/CodeGen/MIRYamlMapping.h
Line
Count
Source (jump to first uncovered line)
1
//===- MIRYAMLMapping.h - Describes the mapping between MIR and YAML ------===//
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 implements the mapping between various MIR data structures and
11
// their corresponding YAML representation.
12
//
13
//===----------------------------------------------------------------------===//
14
15
#ifndef LLVM_CODEGEN_MIRYAMLMAPPING_H
16
#define LLVM_CODEGEN_MIRYAMLMAPPING_H
17
18
#include "llvm/ADT/Optional.h"
19
#include "llvm/ADT/StringRef.h"
20
#include "llvm/CodeGen/MachineJumpTableInfo.h"
21
#include "llvm/Support/SMLoc.h"
22
#include "llvm/Support/YAMLTraits.h"
23
#include "llvm/Support/raw_ostream.h"
24
#include <algorithm>
25
#include <cstdint>
26
#include <string>
27
#include <vector>
28
29
namespace llvm {
30
namespace yaml {
31
32
/// A wrapper around std::string which contains a source range that's being
33
/// set during parsing.
34
0
struct StringValue {
35
  std::string Value;
36
  SMRange SourceRange;
37
38
216k
  StringValue() = default;
39
221
  StringValue(std::string Value) : Value(std::move(Value)) {}
40
41
55.4k
  bool operator==(const StringValue &Other) const {
42
55.4k
    return Value == Other.Value;
43
55.4k
  }
44
};
45
46
template <> struct ScalarTraits<StringValue> {
47
69.0k
  static void output(const StringValue &S, void *, raw_ostream &OS) {
48
69.0k
    OS << S.Value;
49
69.0k
  }
50
51
27.2k
  static StringRef input(StringRef Scalar, void *Ctx, StringValue &S) {
52
27.2k
    S.Value = Scalar.str();
53
27.2k
    if (const auto *Node =
54
27.2k
            reinterpret_cast<yaml::Input *>(Ctx)->getCurrentNode())
55
27.2k
      S.SourceRange = Node->getSourceRange();
56
27.2k
    return "";
57
27.2k
  }
58
59
86.0k
  static QuotingType mustQuote(StringRef S) { return needsQuotes(S); }
60
};
61
62
0
struct FlowStringValue : StringValue {
63
1.23k
  FlowStringValue() = default;
64
77
  FlowStringValue(std::string Value) : StringValue(std::move(Value)) {}
65
};
66
67
template <> struct ScalarTraits<FlowStringValue> {
68
490
  static void output(const FlowStringValue &S, void *, raw_ostream &OS) {
69
490
    return ScalarTraits<StringValue>::output(S, nullptr, OS);
70
490
  }
71
72
822
  static StringRef input(StringRef Scalar, void *Ctx, FlowStringValue &S) {
73
822
    return ScalarTraits<StringValue>::input(Scalar, Ctx, S);
74
822
  }
75
76
1.31k
  static QuotingType mustQuote(StringRef S) { return needsQuotes(S); }
77
};
78
79
0
struct BlockStringValue {
80
  StringValue Value;
81
82
4.58k
  bool operator==(const BlockStringValue &Other) const {
83
4.58k
    return Value == Other.Value;
84
4.58k
  }
85
};
86
87
template <> struct BlockScalarTraits<BlockStringValue> {
88
4.58k
  static void output(const BlockStringValue &S, void *Ctx, raw_ostream &OS) {
89
4.58k
    return ScalarTraits<StringValue>::output(S.Value, Ctx, OS);
90
4.58k
  }
91
92
4.38k
  static StringRef input(StringRef Scalar, void *Ctx, BlockStringValue &S) {
93
4.38k
    return ScalarTraits<StringValue>::input(Scalar, Ctx, S.Value);
94
4.38k
  }
95
};
96
97
/// A wrapper around unsigned which contains a source range that's being set
98
/// during parsing.
99
0
struct UnsignedValue {
100
  unsigned Value = 0;
101
  SMRange SourceRange;
102
103
36.6k
  UnsignedValue() = default;
104
23.0k
  UnsignedValue(unsigned Value) : Value(Value) {}
105
106
0
  bool operator==(const UnsignedValue &Other) const {
107
0
    return Value == Other.Value;
108
0
  }
109
};
110
111
template <> struct ScalarTraits<UnsignedValue> {
112
22.9k
  static void output(const UnsignedValue &Value, void *Ctx, raw_ostream &OS) {
113
22.9k
    return ScalarTraits<unsigned>::output(Value.Value, Ctx, OS);
114
22.9k
  }
115
116
13.6k
  static StringRef input(StringRef Scalar, void *Ctx, UnsignedValue &Value) {
117
13.6k
    if (const auto *Node =
118
13.6k
            reinterpret_cast<yaml::Input *>(Ctx)->getCurrentNode())
119
13.6k
      Value.SourceRange = Node->getSourceRange();
120
13.6k
    return ScalarTraits<unsigned>::input(Scalar, Ctx, Value.Value);
121
13.6k
  }
122
123
36.5k
  static QuotingType mustQuote(StringRef Scalar) {
124
36.5k
    return ScalarTraits<unsigned>::mustQuote(Scalar);
125
36.5k
  }
126
};
127
128
template <> struct ScalarEnumerationTraits<MachineJumpTableInfo::JTEntryKind> {
129
  static void enumeration(yaml::IO &IO,
130
18
                          MachineJumpTableInfo::JTEntryKind &EntryKind) {
131
18
    IO.enumCase(EntryKind, "block-address",
132
18
                MachineJumpTableInfo::EK_BlockAddress);
133
18
    IO.enumCase(EntryKind, "gp-rel64-block-address",
134
18
                MachineJumpTableInfo::EK_GPRel64BlockAddress);
135
18
    IO.enumCase(EntryKind, "gp-rel32-block-address",
136
18
                MachineJumpTableInfo::EK_GPRel32BlockAddress);
137
18
    IO.enumCase(EntryKind, "label-difference32",
138
18
                MachineJumpTableInfo::EK_LabelDifference32);
139
18
    IO.enumCase(EntryKind, "inline", MachineJumpTableInfo::EK_Inline);
140
18
    IO.enumCase(EntryKind, "custom32", MachineJumpTableInfo::EK_Custom32);
141
18
  }
142
};
143
144
} // end namespace yaml
145
} // end namespace llvm
146
147
LLVM_YAML_IS_SEQUENCE_VECTOR(llvm::yaml::StringValue)
148
LLVM_YAML_IS_FLOW_SEQUENCE_VECTOR(llvm::yaml::FlowStringValue)
149
LLVM_YAML_IS_FLOW_SEQUENCE_VECTOR(llvm::yaml::UnsignedValue)
150
151
namespace llvm {
152
namespace yaml {
153
154
0
struct VirtualRegisterDefinition {
155
  UnsignedValue ID;
156
  StringValue Class;
157
  StringValue PreferredRegister;
158
159
  // TODO: Serialize the target specific register hints.
160
161
0
  bool operator==(const VirtualRegisterDefinition &Other) const {
162
0
    return ID == Other.ID && Class == Other.Class &&
163
0
           PreferredRegister == Other.PreferredRegister;
164
0
  }
165
};
166
167
template <> struct MappingTraits<VirtualRegisterDefinition> {
168
35.1k
  static void mapping(IO &YamlIO, VirtualRegisterDefinition &Reg) {
169
35.1k
    YamlIO.mapRequired("id", Reg.ID);
170
35.1k
    YamlIO.mapRequired("class", Reg.Class);
171
35.1k
    YamlIO.mapOptional("preferred-register", Reg.PreferredRegister,
172
35.1k
                       StringValue()); // Don't print out when it's empty.
173
35.1k
  }
174
175
  static const bool flow = true;
176
};
177
178
0
struct MachineFunctionLiveIn {
179
  StringValue Register;
180
  StringValue VirtualRegister;
181
182
0
  bool operator==(const MachineFunctionLiveIn &Other) const {
183
0
    return Register == Other.Register &&
184
0
           VirtualRegister == Other.VirtualRegister;
185
0
  }
186
};
187
188
template <> struct MappingTraits<MachineFunctionLiveIn> {
189
3.21k
  static void mapping(IO &YamlIO, MachineFunctionLiveIn &LiveIn) {
190
3.21k
    YamlIO.mapRequired("reg", LiveIn.Register);
191
3.21k
    YamlIO.mapOptional(
192
3.21k
        "virtual-reg", LiveIn.VirtualRegister,
193
3.21k
        StringValue()); // Don't print the virtual register when it's empty.
194
3.21k
  }
195
196
  static const bool flow = true;
197
};
198
199
/// Serializable representation of stack object from the MachineFrameInfo class.
200
///
201
/// The flags 'isImmutable' and 'isAliased' aren't serialized, as they are
202
/// determined by the object's type and frame information flags.
203
/// Dead stack objects aren't serialized.
204
///
205
/// The 'isPreallocated' flag is determined by the local offset.
206
0
struct MachineStackObject {
207
  enum ObjectType { DefaultType, SpillSlot, VariableSized };
208
  UnsignedValue ID;
209
  StringValue Name;
210
  // TODO: Serialize unnamed LLVM alloca reference.
211
  ObjectType Type = DefaultType;
212
  int64_t Offset = 0;
213
  uint64_t Size = 0;
214
  unsigned Alignment = 0;
215
  uint8_t StackID = 0;
216
  StringValue CalleeSavedRegister;
217
  bool CalleeSavedRestored = true;
218
  Optional<int64_t> LocalOffset;
219
  StringValue DebugVar;
220
  StringValue DebugExpr;
221
  StringValue DebugLoc;
222
223
0
  bool operator==(const MachineStackObject &Other) const {
224
0
    return ID == Other.ID && Name == Other.Name && Type == Other.Type &&
225
0
           Offset == Other.Offset && Size == Other.Size &&
226
0
           Alignment == Other.Alignment &&
227
0
           StackID == Other.StackID &&
228
0
           CalleeSavedRegister == Other.CalleeSavedRegister &&
229
0
           CalleeSavedRestored == Other.CalleeSavedRestored &&
230
0
           LocalOffset == Other.LocalOffset && DebugVar == Other.DebugVar &&
231
0
           DebugExpr == Other.DebugExpr && DebugLoc == Other.DebugLoc;
232
0
  }
233
};
234
235
template <> struct ScalarEnumerationTraits<MachineStackObject::ObjectType> {
236
756
  static void enumeration(yaml::IO &IO, MachineStackObject::ObjectType &Type) {
237
756
    IO.enumCase(Type, "default", MachineStackObject::DefaultType);
238
756
    IO.enumCase(Type, "spill-slot", MachineStackObject::SpillSlot);
239
756
    IO.enumCase(Type, "variable-sized", MachineStackObject::VariableSized);
240
756
  }
241
};
242
243
template <> struct MappingTraits<MachineStackObject> {
244
851
  static void mapping(yaml::IO &YamlIO, MachineStackObject &Object) {
245
851
    YamlIO.mapRequired("id", Object.ID);
246
851
    YamlIO.mapOptional("name", Object.Name,
247
851
                       StringValue()); // Don't print out an empty name.
248
851
    YamlIO.mapOptional(
249
851
        "type", Object.Type,
250
851
        MachineStackObject::DefaultType); // Don't print the default type.
251
851
    YamlIO.mapOptional("offset", Object.Offset, (int64_t)0);
252
851
    if (Object.Type != MachineStackObject::VariableSized)
253
838
      YamlIO.mapRequired("size", Object.Size);
254
851
    YamlIO.mapOptional("alignment", Object.Alignment, (unsigned)0);
255
851
    YamlIO.mapOptional("stack-id", Object.StackID);
256
851
    YamlIO.mapOptional("callee-saved-register", Object.CalleeSavedRegister,
257
851
                       StringValue()); // Don't print it out when it's empty.
258
851
    YamlIO.mapOptional("callee-saved-restored", Object.CalleeSavedRestored,
259
851
                       true);
260
851
    YamlIO.mapOptional("local-offset", Object.LocalOffset, Optional<int64_t>());
261
851
    YamlIO.mapOptional("debug-info-variable", Object.DebugVar,
262
851
                       StringValue()); // Don't print it out when it's empty.
263
851
    YamlIO.mapOptional("debug-info-expression", Object.DebugExpr,
264
851
                       StringValue()); // Don't print it out when it's empty.
265
851
    YamlIO.mapOptional("debug-info-location", Object.DebugLoc,
266
851
                       StringValue()); // Don't print it out when it's empty.
267
851
  }
268
269
  static const bool flow = true;
270
};
271
272
/// Serializable representation of the fixed stack object from the
273
/// MachineFrameInfo class.
274
0
struct FixedMachineStackObject {
275
  enum ObjectType { DefaultType, SpillSlot };
276
  UnsignedValue ID;
277
  ObjectType Type = DefaultType;
278
  int64_t Offset = 0;
279
  uint64_t Size = 0;
280
  unsigned Alignment = 0;
281
  uint8_t StackID = 0;
282
  bool IsImmutable = false;
283
  bool IsAliased = false;
284
  StringValue CalleeSavedRegister;
285
  bool CalleeSavedRestored = true;
286
  StringValue DebugVar;
287
  StringValue DebugExpr;
288
  StringValue DebugLoc;
289
290
0
  bool operator==(const FixedMachineStackObject &Other) const {
291
0
    return ID == Other.ID && Type == Other.Type && Offset == Other.Offset &&
292
0
           Size == Other.Size && Alignment == Other.Alignment &&
293
0
           StackID == Other.StackID &&
294
0
           IsImmutable == Other.IsImmutable && IsAliased == Other.IsAliased &&
295
0
           CalleeSavedRegister == Other.CalleeSavedRegister &&
296
0
           CalleeSavedRestored == Other.CalleeSavedRestored &&
297
0
           DebugVar == Other.DebugVar && DebugExpr == Other.DebugExpr
298
0
           && DebugLoc == Other.DebugLoc;
299
0
  }
300
};
301
302
template <>
303
struct ScalarEnumerationTraits<FixedMachineStackObject::ObjectType> {
304
  static void enumeration(yaml::IO &IO,
305
406
                          FixedMachineStackObject::ObjectType &Type) {
306
406
    IO.enumCase(Type, "default", FixedMachineStackObject::DefaultType);
307
406
    IO.enumCase(Type, "spill-slot", FixedMachineStackObject::SpillSlot);
308
406
  }
309
};
310
311
template <> struct MappingTraits<FixedMachineStackObject> {
312
461
  static void mapping(yaml::IO &YamlIO, FixedMachineStackObject &Object) {
313
461
    YamlIO.mapRequired("id", Object.ID);
314
461
    YamlIO.mapOptional(
315
461
        "type", Object.Type,
316
461
        FixedMachineStackObject::DefaultType); // Don't print the default type.
317
461
    YamlIO.mapOptional("offset", Object.Offset, (int64_t)0);
318
461
    YamlIO.mapOptional("size", Object.Size, (uint64_t)0);
319
461
    YamlIO.mapOptional("alignment", Object.Alignment, (unsigned)0);
320
461
    YamlIO.mapOptional("stack-id", Object.StackID);
321
461
    if (Object.Type != FixedMachineStackObject::SpillSlot) {
322
344
      YamlIO.mapOptional("isImmutable", Object.IsImmutable, false);
323
344
      YamlIO.mapOptional("isAliased", Object.IsAliased, false);
324
344
    }
325
461
    YamlIO.mapOptional("callee-saved-register", Object.CalleeSavedRegister,
326
461
                       StringValue()); // Don't print it out when it's empty.
327
461
    YamlIO.mapOptional("callee-saved-restored", Object.CalleeSavedRestored,
328
461
                     true);
329
461
    YamlIO.mapOptional("debug-info-variable", Object.DebugVar,
330
461
                       StringValue()); // Don't print it out when it's empty.
331
461
    YamlIO.mapOptional("debug-info-expression", Object.DebugExpr,
332
461
                       StringValue()); // Don't print it out when it's empty.
333
461
    YamlIO.mapOptional("debug-info-location", Object.DebugLoc,
334
461
                       StringValue()); // Don't print it out when it's empty.
335
461
  }
336
337
  static const bool flow = true;
338
};
339
340
0
struct MachineConstantPoolValue {
341
  UnsignedValue ID;
342
  StringValue Value;
343
  unsigned Alignment = 0;
344
  bool IsTargetSpecific = false;
345
346
0
  bool operator==(const MachineConstantPoolValue &Other) const {
347
0
    return ID == Other.ID && Value == Other.Value &&
348
0
           Alignment == Other.Alignment &&
349
0
           IsTargetSpecific == Other.IsTargetSpecific;
350
0
  }
351
};
352
353
template <> struct MappingTraits<MachineConstantPoolValue> {
354
89
  static void mapping(IO &YamlIO, MachineConstantPoolValue &Constant) {
355
89
    YamlIO.mapRequired("id", Constant.ID);
356
89
    YamlIO.mapOptional("value", Constant.Value, StringValue());
357
89
    YamlIO.mapOptional("alignment", Constant.Alignment, (unsigned)0);
358
89
    YamlIO.mapOptional("isTargetSpecific", Constant.IsTargetSpecific, false);
359
89
  }
360
};
361
362
0
struct MachineJumpTable {
363
0
  struct Entry {
364
    UnsignedValue ID;
365
    std::vector<FlowStringValue> Blocks;
366
367
0
    bool operator==(const Entry &Other) const {
368
0
      return ID == Other.ID && Blocks == Other.Blocks;
369
0
    }
370
  };
371
372
  MachineJumpTableInfo::JTEntryKind Kind = MachineJumpTableInfo::EK_Custom32;
373
  std::vector<Entry> Entries;
374
375
8
  bool operator==(const MachineJumpTable &Other) const {
376
8
    return Kind == Other.Kind && 
Entries == Other.Entries0
;
377
8
  }
378
};
379
380
template <> struct MappingTraits<MachineJumpTable::Entry> {
381
18
  static void mapping(IO &YamlIO, MachineJumpTable::Entry &Entry) {
382
18
    YamlIO.mapRequired("id", Entry.ID);
383
18
    YamlIO.mapOptional("blocks", Entry.Blocks, std::vector<FlowStringValue>());
384
18
  }
385
};
386
387
} // end namespace yaml
388
} // end namespace llvm
389
390
LLVM_YAML_IS_SEQUENCE_VECTOR(llvm::yaml::MachineFunctionLiveIn)
391
LLVM_YAML_IS_SEQUENCE_VECTOR(llvm::yaml::VirtualRegisterDefinition)
392
LLVM_YAML_IS_SEQUENCE_VECTOR(llvm::yaml::MachineStackObject)
393
LLVM_YAML_IS_SEQUENCE_VECTOR(llvm::yaml::FixedMachineStackObject)
394
LLVM_YAML_IS_SEQUENCE_VECTOR(llvm::yaml::MachineConstantPoolValue)
395
LLVM_YAML_IS_SEQUENCE_VECTOR(llvm::yaml::MachineJumpTable::Entry)
396
397
namespace llvm {
398
namespace yaml {
399
400
template <> struct MappingTraits<MachineJumpTable> {
401
18
  static void mapping(IO &YamlIO, MachineJumpTable &JT) {
402
18
    YamlIO.mapRequired("kind", JT.Kind);
403
18
    YamlIO.mapOptional("entries", JT.Entries,
404
18
                       std::vector<MachineJumpTable::Entry>());
405
18
  }
406
};
407
408
/// Serializable representation of MachineFrameInfo.
409
///
410
/// Doesn't serialize attributes like 'StackAlignment', 'IsStackRealignable' and
411
/// 'RealignOption' as they are determined by the target and LLVM function
412
/// attributes.
413
/// It also doesn't serialize attributes like 'NumFixedObject' and
414
/// 'HasVarSizedObjects' as they are determined by the frame objects themselves.
415
0
struct MachineFrameInfo {
416
  bool IsFrameAddressTaken = false;
417
  bool IsReturnAddressTaken = false;
418
  bool HasStackMap = false;
419
  bool HasPatchPoint = false;
420
  uint64_t StackSize = 0;
421
  int OffsetAdjustment = 0;
422
  unsigned MaxAlignment = 0;
423
  bool AdjustsStack = false;
424
  bool HasCalls = false;
425
  StringValue StackProtector;
426
  // TODO: Serialize FunctionContextIdx
427
  unsigned MaxCallFrameSize = ~0u; ///< ~0u means: not computed yet.
428
  bool HasOpaqueSPAdjustment = false;
429
  bool HasVAStart = false;
430
  bool HasMustTailInVarArgFunc = false;
431
  unsigned LocalFrameSize = 0;
432
  StringValue SavePoint;
433
  StringValue RestorePoint;
434
435
4.58k
  bool operator==(const MachineFrameInfo &Other) const {
436
4.58k
    return IsFrameAddressTaken == Other.IsFrameAddressTaken &&
437
4.58k
           
IsReturnAddressTaken == Other.IsReturnAddressTaken4.57k
&&
438
4.58k
           
HasStackMap == Other.HasStackMap4.57k
&&
439
4.58k
           
HasPatchPoint == Other.HasPatchPoint4.57k
&&
440
4.58k
           
StackSize == Other.StackSize4.57k
&&
441
4.58k
           
OffsetAdjustment == Other.OffsetAdjustment4.46k
&&
442
4.58k
           
MaxAlignment == Other.MaxAlignment4.46k
&&
443
4.58k
           
AdjustsStack == Other.AdjustsStack4.04k
&&
HasCalls == Other.HasCalls4.04k
&&
444
4.58k
           
StackProtector == Other.StackProtector3.85k
&&
445
4.58k
           
MaxCallFrameSize == Other.MaxCallFrameSize3.85k
&&
446
4.58k
           
HasOpaqueSPAdjustment == Other.HasOpaqueSPAdjustment2.76k
&&
447
4.58k
           
HasVAStart == Other.HasVAStart2.76k
&&
448
4.58k
           
HasMustTailInVarArgFunc == Other.HasMustTailInVarArgFunc2.76k
&&
449
4.58k
           
LocalFrameSize == Other.LocalFrameSize2.76k
&&
450
4.58k
           
SavePoint == Other.SavePoint2.76k
&&
RestorePoint == Other.RestorePoint2.76k
;
451
4.58k
  }
452
};
453
454
template <> struct MappingTraits<MachineFrameInfo> {
455
5.27k
  static void mapping(IO &YamlIO, MachineFrameInfo &MFI) {
456
5.27k
    YamlIO.mapOptional("isFrameAddressTaken", MFI.IsFrameAddressTaken, false);
457
5.27k
    YamlIO.mapOptional("isReturnAddressTaken", MFI.IsReturnAddressTaken, false);
458
5.27k
    YamlIO.mapOptional("hasStackMap", MFI.HasStackMap, false);
459
5.27k
    YamlIO.mapOptional("hasPatchPoint", MFI.HasPatchPoint, false);
460
5.27k
    YamlIO.mapOptional("stackSize", MFI.StackSize, (uint64_t)0);
461
5.27k
    YamlIO.mapOptional("offsetAdjustment", MFI.OffsetAdjustment, (int)0);
462
5.27k
    YamlIO.mapOptional("maxAlignment", MFI.MaxAlignment, (unsigned)0);
463
5.27k
    YamlIO.mapOptional("adjustsStack", MFI.AdjustsStack, false);
464
5.27k
    YamlIO.mapOptional("hasCalls", MFI.HasCalls, false);
465
5.27k
    YamlIO.mapOptional("stackProtector", MFI.StackProtector,
466
5.27k
                       StringValue()); // Don't print it out when it's empty.
467
5.27k
    YamlIO.mapOptional("maxCallFrameSize", MFI.MaxCallFrameSize, (unsigned)~0);
468
5.27k
    YamlIO.mapOptional("hasOpaqueSPAdjustment", MFI.HasOpaqueSPAdjustment,
469
5.27k
                       false);
470
5.27k
    YamlIO.mapOptional("hasVAStart", MFI.HasVAStart, false);
471
5.27k
    YamlIO.mapOptional("hasMustTailInVarArgFunc", MFI.HasMustTailInVarArgFunc,
472
5.27k
                       false);
473
5.27k
    YamlIO.mapOptional("localFrameSize", MFI.LocalFrameSize, (unsigned)0);
474
5.27k
    YamlIO.mapOptional("savePoint", MFI.SavePoint,
475
5.27k
                       StringValue()); // Don't print it out when it's empty.
476
5.27k
    YamlIO.mapOptional("restorePoint", MFI.RestorePoint,
477
5.27k
                       StringValue()); // Don't print it out when it's empty.
478
5.27k
  }
479
};
480
481
struct MachineFunction {
482
  StringRef Name;
483
  unsigned Alignment = 0;
484
  bool ExposesReturnsTwice = false;
485
  // GISel MachineFunctionProperties.
486
  bool Legalized = false;
487
  bool RegBankSelected = false;
488
  bool Selected = false;
489
  bool FailedISel = false;
490
  // Register information
491
  bool TracksRegLiveness = false;
492
  std::vector<VirtualRegisterDefinition> VirtualRegisters;
493
  std::vector<MachineFunctionLiveIn> LiveIns;
494
  Optional<std::vector<FlowStringValue>> CalleeSavedRegisters;
495
  // TODO: Serialize the various register masks.
496
  // Frame information
497
  MachineFrameInfo FrameInfo;
498
  std::vector<FixedMachineStackObject> FixedStackObjects;
499
  std::vector<MachineStackObject> StackObjects;
500
  std::vector<MachineConstantPoolValue> Constants; /// Constant pool.
501
  MachineJumpTable JumpTableInfo;
502
  BlockStringValue Body;
503
};
504
505
template <> struct MappingTraits<MachineFunction> {
506
8.98k
  static void mapping(IO &YamlIO, MachineFunction &MF) {
507
8.98k
    YamlIO.mapRequired("name", MF.Name);
508
8.98k
    YamlIO.mapOptional("alignment", MF.Alignment, (unsigned)0);
509
8.98k
    YamlIO.mapOptional("exposesReturnsTwice", MF.ExposesReturnsTwice, false);
510
8.98k
    YamlIO.mapOptional("legalized", MF.Legalized, false);
511
8.98k
    YamlIO.mapOptional("regBankSelected", MF.RegBankSelected, false);
512
8.98k
    YamlIO.mapOptional("selected", MF.Selected, false);
513
8.98k
    YamlIO.mapOptional("failedISel", MF.FailedISel, false);
514
8.98k
    YamlIO.mapOptional("tracksRegLiveness", MF.TracksRegLiveness, false);
515
8.98k
    YamlIO.mapOptional("registers", MF.VirtualRegisters,
516
8.98k
                       std::vector<VirtualRegisterDefinition>());
517
8.98k
    YamlIO.mapOptional("liveins", MF.LiveIns,
518
8.98k
                       std::vector<MachineFunctionLiveIn>());
519
8.98k
    YamlIO.mapOptional("calleeSavedRegisters", MF.CalleeSavedRegisters,
520
8.98k
                       Optional<std::vector<FlowStringValue>>());
521
8.98k
    YamlIO.mapOptional("frameInfo", MF.FrameInfo, MachineFrameInfo());
522
8.98k
    YamlIO.mapOptional("fixedStack", MF.FixedStackObjects,
523
8.98k
                       std::vector<FixedMachineStackObject>());
524
8.98k
    YamlIO.mapOptional("stack", MF.StackObjects,
525
8.98k
                       std::vector<MachineStackObject>());
526
8.98k
    YamlIO.mapOptional("constants", MF.Constants,
527
8.98k
                       std::vector<MachineConstantPoolValue>());
528
8.98k
    if (!YamlIO.outputting() || 
!MF.JumpTableInfo.Entries.empty()4.58k
)
529
4.41k
      YamlIO.mapOptional("jumpTable", MF.JumpTableInfo, MachineJumpTable());
530
8.98k
    YamlIO.mapOptional("body", MF.Body, BlockStringValue());
531
8.98k
  }
532
};
533
534
} // end namespace yaml
535
} // end namespace llvm
536
537
#endif // LLVM_CODEGEN_MIRYAMLMAPPING_H