Coverage Report

Created: 2018-07-19 03:59

/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
197k
  StringValue() = default;
39
219
  StringValue(std::string Value) : Value(std::move(Value)) {}
40
41
49.8k
  bool operator==(const StringValue &Other) const {
42
49.8k
    return Value == Other.Value;
43
49.8k
  }
44
};
45
46
template <> struct ScalarTraits<StringValue> {
47
62.2k
  static void output(const StringValue &S, void *, raw_ostream &OS) {
48
62.2k
    OS << S.Value;
49
62.2k
  }
50
51
25.6k
  static StringRef input(StringRef Scalar, void *Ctx, StringValue &S) {
52
25.6k
    S.Value = Scalar.str();
53
25.6k
    if (const auto *Node =
54
25.6k
            reinterpret_cast<yaml::Input *>(Ctx)->getCurrentNode())
55
25.6k
      S.SourceRange = Node->getSourceRange();
56
25.6k
    return "";
57
25.6k
  }
58
59
78.4k
  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.15k
  bool operator==(const BlockStringValue &Other) const {
83
4.15k
    return Value == Other.Value;
84
4.15k
  }
85
};
86
87
template <> struct BlockScalarTraits<BlockStringValue> {
88
4.15k
  static void output(const BlockStringValue &S, void *Ctx, raw_ostream &OS) {
89
4.15k
    return ScalarTraits<StringValue>::output(S.Value, Ctx, OS);
90
4.15k
  }
91
92
3.99k
  static StringRef input(StringRef Scalar, void *Ctx, BlockStringValue &S) {
93
3.99k
    return ScalarTraits<StringValue>::input(Scalar, Ctx, S.Value);
94
3.99k
  }
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
33.3k
  UnsignedValue() = default;
104
20.7k
  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
20.6k
  static void output(const UnsignedValue &Value, void *Ctx, raw_ostream &OS) {
113
20.6k
    return ScalarTraits<unsigned>::output(Value.Value, Ctx, OS);
114
20.6k
  }
115
116
12.6k
  static StringRef input(StringRef Scalar, void *Ctx, UnsignedValue &Value) {
117
12.6k
    if (const auto *Node =
118
12.6k
            reinterpret_cast<yaml::Input *>(Ctx)->getCurrentNode())
119
12.6k
      Value.SourceRange = Node->getSourceRange();
120
12.6k
    return ScalarTraits<unsigned>::input(Scalar, Ctx, Value.Value);
121
12.6k
  }
122
123
33.2k
  static QuotingType mustQuote(StringRef Scalar) {
124
33.2k
    return ScalarTraits<unsigned>::mustQuote(Scalar);
125
33.2k
  }
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
31.9k
  static void mapping(IO &YamlIO, VirtualRegisterDefinition &Reg) {
169
31.9k
    YamlIO.mapRequired("id", Reg.ID);
170
31.9k
    YamlIO.mapRequired("class", Reg.Class);
171
31.9k
    YamlIO.mapOptional("preferred-register", Reg.PreferredRegister,
172
31.9k
                       StringValue()); // Don't print out when it's empty.
173
31.9k
  }
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.12k
  static void mapping(IO &YamlIO, MachineFunctionLiveIn &LiveIn) {
190
3.12k
    YamlIO.mapRequired("reg", LiveIn.Register);
191
3.12k
    YamlIO.mapOptional(
192
3.12k
        "virtual-reg", LiveIn.VirtualRegister,
193
3.12k
        StringValue()); // Don't print the virtual register when it's empty.
194
3.12k
  }
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
611
  static void enumeration(yaml::IO &IO, MachineStackObject::ObjectType &Type) {
237
611
    IO.enumCase(Type, "default", MachineStackObject::DefaultType);
238
611
    IO.enumCase(Type, "spill-slot", MachineStackObject::SpillSlot);
239
611
    IO.enumCase(Type, "variable-sized", MachineStackObject::VariableSized);
240
611
  }
241
};
242
243
template <> struct MappingTraits<MachineStackObject> {
244
701
  static void mapping(yaml::IO &YamlIO, MachineStackObject &Object) {
245
701
    YamlIO.mapRequired("id", Object.ID);
246
701
    YamlIO.mapOptional("name", Object.Name,
247
701
                       StringValue()); // Don't print out an empty name.
248
701
    YamlIO.mapOptional(
249
701
        "type", Object.Type,
250
701
        MachineStackObject::DefaultType); // Don't print the default type.
251
701
    YamlIO.mapOptional("offset", Object.Offset, (int64_t)0);
252
701
    if (Object.Type != MachineStackObject::VariableSized)
253
688
      YamlIO.mapRequired("size", Object.Size);
254
701
    YamlIO.mapOptional("alignment", Object.Alignment, (unsigned)0);
255
701
    YamlIO.mapOptional("stack-id", Object.StackID);
256
701
    YamlIO.mapOptional("callee-saved-register", Object.CalleeSavedRegister,
257
701
                       StringValue()); // Don't print it out when it's empty.
258
701
    YamlIO.mapOptional("callee-saved-restored", Object.CalleeSavedRestored,
259
701
                       true);
260
701
    YamlIO.mapOptional("local-offset", Object.LocalOffset, Optional<int64_t>());
261
701
    YamlIO.mapOptional("debug-info-variable", Object.DebugVar,
262
701
                       StringValue()); // Don't print it out when it's empty.
263
701
    YamlIO.mapOptional("debug-info-expression", Object.DebugExpr,
264
701
                       StringValue()); // Don't print it out when it's empty.
265
701
    YamlIO.mapOptional("debug-info-location", Object.DebugLoc,
266
701
                       StringValue()); // Don't print it out when it's empty.
267
701
  }
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
396
                          FixedMachineStackObject::ObjectType &Type) {
306
396
    IO.enumCase(Type, "default", FixedMachineStackObject::DefaultType);
307
396
    IO.enumCase(Type, "spill-slot", FixedMachineStackObject::SpillSlot);
308
396
  }
309
};
310
311
template <> struct MappingTraits<FixedMachineStackObject> {
312
448
  static void mapping(yaml::IO &YamlIO, FixedMachineStackObject &Object) {
313
448
    YamlIO.mapRequired("id", Object.ID);
314
448
    YamlIO.mapOptional(
315
448
        "type", Object.Type,
316
448
        FixedMachineStackObject::DefaultType); // Don't print the default type.
317
448
    YamlIO.mapOptional("offset", Object.Offset, (int64_t)0);
318
448
    YamlIO.mapOptional("size", Object.Size, (uint64_t)0);
319
448
    YamlIO.mapOptional("alignment", Object.Alignment, (unsigned)0);
320
448
    YamlIO.mapOptional("stack-id", Object.StackID);
321
448
    if (Object.Type != FixedMachineStackObject::SpillSlot) {
322
331
      YamlIO.mapOptional("isImmutable", Object.IsImmutable, false);
323
331
      YamlIO.mapOptional("isAliased", Object.IsAliased, false);
324
331
    }
325
448
    YamlIO.mapOptional("callee-saved-register", Object.CalleeSavedRegister,
326
448
                       StringValue()); // Don't print it out when it's empty.
327
448
    YamlIO.mapOptional("callee-saved-restored", Object.CalleeSavedRestored,
328
448
                     true);
329
448
    YamlIO.mapOptional("debug-info-variable", Object.DebugVar,
330
448
                       StringValue()); // Don't print it out when it's empty.
331
448
    YamlIO.mapOptional("debug-info-expression", Object.DebugExpr,
332
448
                       StringValue()); // Don't print it out when it's empty.
333
448
    YamlIO.mapOptional("debug-info-location", Object.DebugLoc,
334
448
                       StringValue()); // Don't print it out when it's empty.
335
448
  }
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
86
  static void mapping(IO &YamlIO, MachineConstantPoolValue &Constant) {
355
86
    YamlIO.mapRequired("id", Constant.ID);
356
86
    YamlIO.mapOptional("value", Constant.Value, StringValue());
357
86
    YamlIO.mapOptional("alignment", Constant.Alignment, (unsigned)0);
358
86
    YamlIO.mapOptional("isTargetSpecific", Constant.IsTargetSpecific, false);
359
86
  }
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.15k
  bool operator==(const MachineFrameInfo &Other) const {
436
4.15k
    return IsFrameAddressTaken == Other.IsFrameAddressTaken &&
437
4.15k
           
IsReturnAddressTaken == Other.IsReturnAddressTaken4.15k
&&
438
4.15k
           
HasStackMap == Other.HasStackMap4.15k
&&
439
4.15k
           
HasPatchPoint == Other.HasPatchPoint4.14k
&&
440
4.15k
           
StackSize == Other.StackSize4.14k
&&
441
4.15k
           
OffsetAdjustment == Other.OffsetAdjustment4.06k
&&
442
4.15k
           
MaxAlignment == Other.MaxAlignment4.06k
&&
443
4.15k
           
AdjustsStack == Other.AdjustsStack3.68k
&&
HasCalls == Other.HasCalls3.68k
&&
444
4.15k
           
StackProtector == Other.StackProtector3.50k
&&
445
4.15k
           
MaxCallFrameSize == Other.MaxCallFrameSize3.50k
&&
446
4.15k
           
HasOpaqueSPAdjustment == Other.HasOpaqueSPAdjustment2.41k
&&
447
4.15k
           
HasVAStart == Other.HasVAStart2.41k
&&
448
4.15k
           
HasMustTailInVarArgFunc == Other.HasMustTailInVarArgFunc2.41k
&&
449
4.15k
           
LocalFrameSize == Other.LocalFrameSize2.41k
&&
450
4.15k
           
SavePoint == Other.SavePoint2.41k
&&
RestorePoint == Other.RestorePoint2.41k
;
451
4.15k
  }
452
};
453
454
template <> struct MappingTraits<MachineFrameInfo> {
455
4.84k
  static void mapping(IO &YamlIO, MachineFrameInfo &MFI) {
456
4.84k
    YamlIO.mapOptional("isFrameAddressTaken", MFI.IsFrameAddressTaken, false);
457
4.84k
    YamlIO.mapOptional("isReturnAddressTaken", MFI.IsReturnAddressTaken, false);
458
4.84k
    YamlIO.mapOptional("hasStackMap", MFI.HasStackMap, false);
459
4.84k
    YamlIO.mapOptional("hasPatchPoint", MFI.HasPatchPoint, false);
460
4.84k
    YamlIO.mapOptional("stackSize", MFI.StackSize, (uint64_t)0);
461
4.84k
    YamlIO.mapOptional("offsetAdjustment", MFI.OffsetAdjustment, (int)0);
462
4.84k
    YamlIO.mapOptional("maxAlignment", MFI.MaxAlignment, (unsigned)0);
463
4.84k
    YamlIO.mapOptional("adjustsStack", MFI.AdjustsStack, false);
464
4.84k
    YamlIO.mapOptional("hasCalls", MFI.HasCalls, false);
465
4.84k
    YamlIO.mapOptional("stackProtector", MFI.StackProtector,
466
4.84k
                       StringValue()); // Don't print it out when it's empty.
467
4.84k
    YamlIO.mapOptional("maxCallFrameSize", MFI.MaxCallFrameSize, (unsigned)~0);
468
4.84k
    YamlIO.mapOptional("hasOpaqueSPAdjustment", MFI.HasOpaqueSPAdjustment,
469
4.84k
                       false);
470
4.84k
    YamlIO.mapOptional("hasVAStart", MFI.HasVAStart, false);
471
4.84k
    YamlIO.mapOptional("hasMustTailInVarArgFunc", MFI.HasMustTailInVarArgFunc,
472
4.84k
                       false);
473
4.84k
    YamlIO.mapOptional("localFrameSize", MFI.LocalFrameSize, (unsigned)0);
474
4.84k
    YamlIO.mapOptional("savePoint", MFI.SavePoint,
475
4.84k
                       StringValue()); // Don't print it out when it's empty.
476
4.84k
    YamlIO.mapOptional("restorePoint", MFI.RestorePoint,
477
4.84k
                       StringValue()); // Don't print it out when it's empty.
478
4.84k
  }
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.16k
  static void mapping(IO &YamlIO, MachineFunction &MF) {
507
8.16k
    YamlIO.mapRequired("name", MF.Name);
508
8.16k
    YamlIO.mapOptional("alignment", MF.Alignment, (unsigned)0);
509
8.16k
    YamlIO.mapOptional("exposesReturnsTwice", MF.ExposesReturnsTwice, false);
510
8.16k
    YamlIO.mapOptional("legalized", MF.Legalized, false);
511
8.16k
    YamlIO.mapOptional("regBankSelected", MF.RegBankSelected, false);
512
8.16k
    YamlIO.mapOptional("selected", MF.Selected, false);
513
8.16k
    YamlIO.mapOptional("failedISel", MF.FailedISel, false);
514
8.16k
    YamlIO.mapOptional("tracksRegLiveness", MF.TracksRegLiveness, false);
515
8.16k
    YamlIO.mapOptional("registers", MF.VirtualRegisters,
516
8.16k
                       std::vector<VirtualRegisterDefinition>());
517
8.16k
    YamlIO.mapOptional("liveins", MF.LiveIns,
518
8.16k
                       std::vector<MachineFunctionLiveIn>());
519
8.16k
    YamlIO.mapOptional("calleeSavedRegisters", MF.CalleeSavedRegisters,
520
8.16k
                       Optional<std::vector<FlowStringValue>>());
521
8.16k
    YamlIO.mapOptional("frameInfo", MF.FrameInfo, MachineFrameInfo());
522
8.16k
    YamlIO.mapOptional("fixedStack", MF.FixedStackObjects,
523
8.16k
                       std::vector<FixedMachineStackObject>());
524
8.16k
    YamlIO.mapOptional("stack", MF.StackObjects,
525
8.16k
                       std::vector<MachineStackObject>());
526
8.16k
    YamlIO.mapOptional("constants", MF.Constants,
527
8.16k
                       std::vector<MachineConstantPoolValue>());
528
8.16k
    if (!YamlIO.outputting() || 
!MF.JumpTableInfo.Entries.empty()4.15k
)
529
4.01k
      YamlIO.mapOptional("jumpTable", MF.JumpTableInfo, MachineJumpTable());
530
8.16k
    YamlIO.mapOptional("body", MF.Body, BlockStringValue());
531
8.16k
  }
532
};
533
534
} // end namespace yaml
535
} // end namespace llvm
536
537
#endif // LLVM_CODEGEN_MIRYAMLMAPPING_H