Line data Source code
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 17349 : struct StringValue {
35 : std::string Value;
36 : SMRange SourceRange;
37 :
38 : StringValue() = default;
39 231 : StringValue(std::string Value) : Value(std::move(Value)) {}
40 :
41 : bool operator==(const StringValue &Other) const {
42 47926 : return Value == Other.Value;
43 : }
44 : };
45 :
46 : template <> struct ScalarTraits<StringValue> {
47 0 : static void output(const StringValue &S, void *, raw_ostream &OS) {
48 : OS << S.Value;
49 0 : }
50 :
51 28259 : static StringRef input(StringRef Scalar, void *Ctx, StringValue &S) {
52 56518 : S.Value = Scalar.str();
53 28259 : if (const auto *Node =
54 28259 : reinterpret_cast<yaml::Input *>(Ctx)->getCurrentNode())
55 28259 : S.SourceRange = Node->getSourceRange();
56 28259 : return "";
57 : }
58 :
59 89388 : static QuotingType mustQuote(StringRef S) { return needsQuotes(S); }
60 : };
61 :
62 3896 : struct FlowStringValue : StringValue {
63 : FlowStringValue() = default;
64 82 : FlowStringValue(std::string Value) : StringValue(std::move(Value)) {}
65 : };
66 :
67 : template <> struct ScalarTraits<FlowStringValue> {
68 0 : static void output(const FlowStringValue &S, void *, raw_ostream &OS) {
69 0 : return ScalarTraits<StringValue>::output(S, nullptr, OS);
70 : }
71 :
72 : static StringRef input(StringRef Scalar, void *Ctx, FlowStringValue &S) {
73 827 : return ScalarTraits<StringValue>::input(Scalar, Ctx, S);
74 : }
75 :
76 1322 : static QuotingType mustQuote(StringRef S) { return needsQuotes(S); }
77 : };
78 :
79 : struct BlockStringValue {
80 : StringValue Value;
81 :
82 : bool operator==(const BlockStringValue &Other) const {
83 : return Value == Other.Value;
84 : }
85 : };
86 :
87 : template <> struct BlockScalarTraits<BlockStringValue> {
88 0 : static void output(const BlockStringValue &S, void *Ctx, raw_ostream &OS) {
89 0 : return ScalarTraits<StringValue>::output(S.Value, Ctx, OS);
90 : }
91 :
92 : static StringRef input(StringRef Scalar, void *Ctx, BlockStringValue &S) {
93 4567 : return ScalarTraits<StringValue>::input(Scalar, Ctx, S.Value);
94 : }
95 : };
96 :
97 : /// A wrapper around unsigned which contains a source range that's being set
98 : /// during parsing.
99 : struct UnsignedValue {
100 : unsigned Value = 0;
101 : SMRange SourceRange;
102 :
103 13586 : UnsignedValue() = default;
104 : UnsignedValue(unsigned Value) : Value(Value) {}
105 :
106 0 : bool operator==(const UnsignedValue &Other) const {
107 0 : return Value == Other.Value;
108 : }
109 : };
110 :
111 : template <> struct ScalarTraits<UnsignedValue> {
112 : static void output(const UnsignedValue &Value, void *Ctx, raw_ostream &OS) {
113 23828 : return ScalarTraits<unsigned>::output(Value.Value, Ctx, OS);
114 : }
115 :
116 13881 : static StringRef input(StringRef Scalar, void *Ctx, UnsignedValue &Value) {
117 13881 : if (const auto *Node =
118 13881 : reinterpret_cast<yaml::Input *>(Ctx)->getCurrentNode())
119 13881 : Value.SourceRange = Node->getSourceRange();
120 13881 : return ScalarTraits<unsigned>::input(Scalar, Ctx, Value.Value);
121 : }
122 :
123 0 : static QuotingType mustQuote(StringRef Scalar) {
124 0 : return ScalarTraits<unsigned>::mustQuote(Scalar);
125 : }
126 : };
127 :
128 : template <> struct ScalarEnumerationTraits<MachineJumpTableInfo::JTEntryKind> {
129 20 : static void enumeration(yaml::IO &IO,
130 : MachineJumpTableInfo::JTEntryKind &EntryKind) {
131 20 : IO.enumCase(EntryKind, "block-address",
132 : MachineJumpTableInfo::EK_BlockAddress);
133 20 : IO.enumCase(EntryKind, "gp-rel64-block-address",
134 : MachineJumpTableInfo::EK_GPRel64BlockAddress);
135 20 : IO.enumCase(EntryKind, "gp-rel32-block-address",
136 : MachineJumpTableInfo::EK_GPRel32BlockAddress);
137 20 : IO.enumCase(EntryKind, "label-difference32",
138 : MachineJumpTableInfo::EK_LabelDifference32);
139 20 : IO.enumCase(EntryKind, "inline", MachineJumpTableInfo::EK_Inline);
140 20 : IO.enumCase(EntryKind, "custom32", MachineJumpTableInfo::EK_Custom32);
141 20 : }
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 : 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 : }
165 : };
166 :
167 : template <> struct MappingTraits<VirtualRegisterDefinition> {
168 36204 : static void mapping(IO &YamlIO, VirtualRegisterDefinition &Reg) {
169 36204 : YamlIO.mapRequired("id", Reg.ID);
170 36204 : YamlIO.mapRequired("class", Reg.Class);
171 36204 : YamlIO.mapOptional("preferred-register", Reg.PreferredRegister,
172 36204 : StringValue()); // Don't print out when it's empty.
173 36204 : }
174 :
175 : static const bool flow = true;
176 : };
177 :
178 : 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 : }
186 : };
187 :
188 : template <> struct MappingTraits<MachineFunctionLiveIn> {
189 3364 : static void mapping(IO &YamlIO, MachineFunctionLiveIn &LiveIn) {
190 3364 : YamlIO.mapRequired("reg", LiveIn.Register);
191 : YamlIO.mapOptional(
192 3364 : "virtual-reg", LiveIn.VirtualRegister,
193 3364 : StringValue()); // Don't print the virtual register when it's empty.
194 3364 : }
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 : 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 : }
233 : };
234 :
235 : template <> struct ScalarEnumerationTraits<MachineStackObject::ObjectType> {
236 771 : static void enumeration(yaml::IO &IO, MachineStackObject::ObjectType &Type) {
237 771 : IO.enumCase(Type, "default", MachineStackObject::DefaultType);
238 771 : IO.enumCase(Type, "spill-slot", MachineStackObject::SpillSlot);
239 771 : IO.enumCase(Type, "variable-sized", MachineStackObject::VariableSized);
240 771 : }
241 : };
242 :
243 : template <> struct MappingTraits<MachineStackObject> {
244 866 : static void mapping(yaml::IO &YamlIO, MachineStackObject &Object) {
245 866 : YamlIO.mapRequired("id", Object.ID);
246 866 : YamlIO.mapOptional("name", Object.Name,
247 866 : StringValue()); // Don't print out an empty name.
248 : YamlIO.mapOptional(
249 866 : "type", Object.Type,
250 866 : MachineStackObject::DefaultType); // Don't print the default type.
251 866 : YamlIO.mapOptional("offset", Object.Offset, (int64_t)0);
252 866 : if (Object.Type != MachineStackObject::VariableSized)
253 853 : YamlIO.mapRequired("size", Object.Size);
254 866 : YamlIO.mapOptional("alignment", Object.Alignment, (unsigned)0);
255 866 : YamlIO.mapOptional("stack-id", Object.StackID);
256 866 : YamlIO.mapOptional("callee-saved-register", Object.CalleeSavedRegister,
257 866 : StringValue()); // Don't print it out when it's empty.
258 866 : YamlIO.mapOptional("callee-saved-restored", Object.CalleeSavedRestored,
259 866 : true);
260 866 : YamlIO.mapOptional("local-offset", Object.LocalOffset, Optional<int64_t>());
261 866 : YamlIO.mapOptional("debug-info-variable", Object.DebugVar,
262 866 : StringValue()); // Don't print it out when it's empty.
263 866 : YamlIO.mapOptional("debug-info-expression", Object.DebugExpr,
264 866 : StringValue()); // Don't print it out when it's empty.
265 866 : YamlIO.mapOptional("debug-info-location", Object.DebugLoc,
266 866 : StringValue()); // Don't print it out when it's empty.
267 866 : }
268 :
269 : static const bool flow = true;
270 : };
271 :
272 : /// Serializable representation of the fixed stack object from the
273 : /// MachineFrameInfo class.
274 906 : 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 : 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 : }
300 : };
301 :
302 : template <>
303 : struct ScalarEnumerationTraits<FixedMachineStackObject::ObjectType> {
304 475 : static void enumeration(yaml::IO &IO,
305 : FixedMachineStackObject::ObjectType &Type) {
306 475 : IO.enumCase(Type, "default", FixedMachineStackObject::DefaultType);
307 475 : IO.enumCase(Type, "spill-slot", FixedMachineStackObject::SpillSlot);
308 475 : }
309 : };
310 :
311 : template <> struct MappingTraits<FixedMachineStackObject> {
312 530 : static void mapping(yaml::IO &YamlIO, FixedMachineStackObject &Object) {
313 530 : YamlIO.mapRequired("id", Object.ID);
314 : YamlIO.mapOptional(
315 530 : "type", Object.Type,
316 530 : FixedMachineStackObject::DefaultType); // Don't print the default type.
317 530 : YamlIO.mapOptional("offset", Object.Offset, (int64_t)0);
318 530 : YamlIO.mapOptional("size", Object.Size, (uint64_t)0);
319 530 : YamlIO.mapOptional("alignment", Object.Alignment, (unsigned)0);
320 530 : YamlIO.mapOptional("stack-id", Object.StackID);
321 530 : if (Object.Type != FixedMachineStackObject::SpillSlot) {
322 411 : YamlIO.mapOptional("isImmutable", Object.IsImmutable, false);
323 411 : YamlIO.mapOptional("isAliased", Object.IsAliased, false);
324 : }
325 530 : YamlIO.mapOptional("callee-saved-register", Object.CalleeSavedRegister,
326 530 : StringValue()); // Don't print it out when it's empty.
327 530 : YamlIO.mapOptional("callee-saved-restored", Object.CalleeSavedRestored,
328 530 : true);
329 530 : YamlIO.mapOptional("debug-info-variable", Object.DebugVar,
330 530 : StringValue()); // Don't print it out when it's empty.
331 530 : YamlIO.mapOptional("debug-info-expression", Object.DebugExpr,
332 530 : StringValue()); // Don't print it out when it's empty.
333 530 : YamlIO.mapOptional("debug-info-location", Object.DebugLoc,
334 530 : StringValue()); // Don't print it out when it's empty.
335 530 : }
336 :
337 : static const bool flow = true;
338 : };
339 :
340 303 : 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 : }
351 : };
352 :
353 : template <> struct MappingTraits<MachineConstantPoolValue> {
354 89 : static void mapping(IO &YamlIO, MachineConstantPoolValue &Constant) {
355 89 : YamlIO.mapRequired("id", Constant.ID);
356 178 : 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 9164 : struct MachineJumpTable {
363 40 : struct Entry {
364 : UnsignedValue ID;
365 : std::vector<FlowStringValue> Blocks;
366 :
367 : bool operator==(const Entry &Other) const {
368 0 : return ID == Other.ID && Blocks == Other.Blocks;
369 : }
370 : };
371 :
372 : MachineJumpTableInfo::JTEntryKind Kind = MachineJumpTableInfo::EK_Custom32;
373 : std::vector<Entry> Entries;
374 :
375 : bool operator==(const MachineJumpTable &Other) const {
376 9 : return Kind == Other.Kind && Entries == Other.Entries;
377 : }
378 : };
379 :
380 : template <> struct MappingTraits<MachineJumpTable::Entry> {
381 20 : static void mapping(IO &YamlIO, MachineJumpTable::Entry &Entry) {
382 20 : YamlIO.mapRequired("id", Entry.ID);
383 20 : YamlIO.mapOptional("blocks", Entry.Blocks, std::vector<FlowStringValue>());
384 20 : }
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 20 : static void mapping(IO &YamlIO, MachineJumpTable &JT) {
402 20 : YamlIO.mapRequired("kind", JT.Kind);
403 20 : YamlIO.mapOptional("entries", JT.Entries,
404 20 : std::vector<MachineJumpTable::Entry>());
405 20 : }
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 9349 : 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 : unsigned CVBytesOfCalleeSavedRegisters = 0;
429 : bool HasOpaqueSPAdjustment = false;
430 : bool HasVAStart = false;
431 : bool HasMustTailInVarArgFunc = false;
432 : unsigned LocalFrameSize = 0;
433 : StringValue SavePoint;
434 : StringValue RestorePoint;
435 :
436 4764 : bool operator==(const MachineFrameInfo &Other) const {
437 : return IsFrameAddressTaken == Other.IsFrameAddressTaken &&
438 : IsReturnAddressTaken == Other.IsReturnAddressTaken &&
439 4764 : HasStackMap == Other.HasStackMap &&
440 4754 : HasPatchPoint == Other.HasPatchPoint &&
441 4754 : StackSize == Other.StackSize &&
442 4651 : OffsetAdjustment == Other.OffsetAdjustment &&
443 : MaxAlignment == Other.MaxAlignment &&
444 4201 : AdjustsStack == Other.AdjustsStack && HasCalls == Other.HasCalls &&
445 : StackProtector == Other.StackProtector &&
446 4013 : MaxCallFrameSize == Other.MaxCallFrameSize &&
447 : CVBytesOfCalleeSavedRegisters ==
448 : Other.CVBytesOfCalleeSavedRegisters &&
449 : HasOpaqueSPAdjustment == Other.HasOpaqueSPAdjustment &&
450 : HasVAStart == Other.HasVAStart &&
451 2886 : HasMustTailInVarArgFunc == Other.HasMustTailInVarArgFunc &&
452 2886 : LocalFrameSize == Other.LocalFrameSize &&
453 7650 : SavePoint == Other.SavePoint && RestorePoint == Other.RestorePoint;
454 : }
455 : };
456 :
457 : template <> struct MappingTraits<MachineFrameInfo> {
458 5505 : static void mapping(IO &YamlIO, MachineFrameInfo &MFI) {
459 5505 : YamlIO.mapOptional("isFrameAddressTaken", MFI.IsFrameAddressTaken, false);
460 5505 : YamlIO.mapOptional("isReturnAddressTaken", MFI.IsReturnAddressTaken, false);
461 5505 : YamlIO.mapOptional("hasStackMap", MFI.HasStackMap, false);
462 5505 : YamlIO.mapOptional("hasPatchPoint", MFI.HasPatchPoint, false);
463 5505 : YamlIO.mapOptional("stackSize", MFI.StackSize, (uint64_t)0);
464 5505 : YamlIO.mapOptional("offsetAdjustment", MFI.OffsetAdjustment, (int)0);
465 5505 : YamlIO.mapOptional("maxAlignment", MFI.MaxAlignment, (unsigned)0);
466 5505 : YamlIO.mapOptional("adjustsStack", MFI.AdjustsStack, false);
467 5505 : YamlIO.mapOptional("hasCalls", MFI.HasCalls, false);
468 5505 : YamlIO.mapOptional("stackProtector", MFI.StackProtector,
469 5505 : StringValue()); // Don't print it out when it's empty.
470 5505 : YamlIO.mapOptional("maxCallFrameSize", MFI.MaxCallFrameSize, (unsigned)~0);
471 : YamlIO.mapOptional("cvBytesOfCalleeSavedRegisters",
472 5505 : MFI.CVBytesOfCalleeSavedRegisters, 0U);
473 5505 : YamlIO.mapOptional("hasOpaqueSPAdjustment", MFI.HasOpaqueSPAdjustment,
474 5505 : false);
475 5505 : YamlIO.mapOptional("hasVAStart", MFI.HasVAStart, false);
476 5505 : YamlIO.mapOptional("hasMustTailInVarArgFunc", MFI.HasMustTailInVarArgFunc,
477 5505 : false);
478 5505 : YamlIO.mapOptional("localFrameSize", MFI.LocalFrameSize, (unsigned)0);
479 5505 : YamlIO.mapOptional("savePoint", MFI.SavePoint,
480 5505 : StringValue()); // Don't print it out when it's empty.
481 5505 : YamlIO.mapOptional("restorePoint", MFI.RestorePoint,
482 5505 : StringValue()); // Don't print it out when it's empty.
483 5505 : }
484 : };
485 :
486 : struct MachineFunction {
487 : StringRef Name;
488 : unsigned Alignment = 0;
489 : bool ExposesReturnsTwice = false;
490 : // GISel MachineFunctionProperties.
491 : bool Legalized = false;
492 : bool RegBankSelected = false;
493 : bool Selected = false;
494 : bool FailedISel = false;
495 : // Register information
496 : bool TracksRegLiveness = false;
497 : std::vector<VirtualRegisterDefinition> VirtualRegisters;
498 : std::vector<MachineFunctionLiveIn> LiveIns;
499 : Optional<std::vector<FlowStringValue>> CalleeSavedRegisters;
500 : // TODO: Serialize the various register masks.
501 : // Frame information
502 : MachineFrameInfo FrameInfo;
503 : std::vector<FixedMachineStackObject> FixedStackObjects;
504 : std::vector<MachineStackObject> StackObjects;
505 : std::vector<MachineConstantPoolValue> Constants; /// Constant pool.
506 : MachineJumpTable JumpTableInfo;
507 : BlockStringValue Body;
508 : };
509 :
510 : template <> struct MappingTraits<MachineFunction> {
511 9349 : static void mapping(IO &YamlIO, MachineFunction &MF) {
512 9349 : YamlIO.mapRequired("name", MF.Name);
513 9349 : YamlIO.mapOptional("alignment", MF.Alignment, (unsigned)0);
514 9349 : YamlIO.mapOptional("exposesReturnsTwice", MF.ExposesReturnsTwice, false);
515 9349 : YamlIO.mapOptional("legalized", MF.Legalized, false);
516 9349 : YamlIO.mapOptional("regBankSelected", MF.RegBankSelected, false);
517 9349 : YamlIO.mapOptional("selected", MF.Selected, false);
518 9349 : YamlIO.mapOptional("failedISel", MF.FailedISel, false);
519 9349 : YamlIO.mapOptional("tracksRegLiveness", MF.TracksRegLiveness, false);
520 9349 : YamlIO.mapOptional("registers", MF.VirtualRegisters,
521 9349 : std::vector<VirtualRegisterDefinition>());
522 9349 : YamlIO.mapOptional("liveins", MF.LiveIns,
523 9349 : std::vector<MachineFunctionLiveIn>());
524 9349 : YamlIO.mapOptional("calleeSavedRegisters", MF.CalleeSavedRegisters,
525 9349 : Optional<std::vector<FlowStringValue>>());
526 18698 : YamlIO.mapOptional("frameInfo", MF.FrameInfo, MachineFrameInfo());
527 9349 : YamlIO.mapOptional("fixedStack", MF.FixedStackObjects,
528 9349 : std::vector<FixedMachineStackObject>());
529 9349 : YamlIO.mapOptional("stack", MF.StackObjects,
530 9349 : std::vector<MachineStackObject>());
531 9349 : YamlIO.mapOptional("constants", MF.Constants,
532 9349 : std::vector<MachineConstantPoolValue>());
533 9349 : if (!YamlIO.outputting() || !MF.JumpTableInfo.Entries.empty())
534 9188 : YamlIO.mapOptional("jumpTable", MF.JumpTableInfo, MachineJumpTable());
535 18698 : YamlIO.mapOptional("body", MF.Body, BlockStringValue());
536 9349 : }
537 : };
538 :
539 : } // end namespace yaml
540 : } // end namespace llvm
541 :
542 : #endif // LLVM_CODEGEN_MIRYAMLMAPPING_H
|
