contrib/llvm/include/llvm/CodeGen/MIRYamlMapping.h

   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 struct StringValue {
  35   std::string Value;
  36   SMRange SourceRange;
  37
  38   StringValue() = default;
  39   StringValue(std::string Value) : Value(std::move(Value)) {}
  40
  41   bool operator==(const StringValue &Other) const {
  42     return Value == Other.Value;
  43   }
  44 };
  45
  46 template <> struct ScalarTraits<StringValue> {
  47   static void output(const StringValue &S, void *, raw_ostream &OS) {
  48     OS << S.Value;
  49   }
  50
  51   static StringRef input(StringRef Scalar, void *Ctx, StringValue &S) {
  52     S.Value = Scalar.str();
  53     if (const auto *Node =
  54             reinterpret_cast<yaml::Input *>(Ctx)->getCurrentNode())
  55       S.SourceRange = Node->getSourceRange();
  56     return "";
  57   }
  58
  59   static QuotingType mustQuote(StringRef S) { return needsQuotes(S); }
  60 };
  61
  62 struct FlowStringValue : StringValue {
  63   FlowStringValue() = default;
  64   FlowStringValue(std::string Value) : StringValue(std::move(Value)) {}
  65 };
  66
  67 template <> struct ScalarTraits<FlowStringValue> {
  68   static void output(const FlowStringValue &S, void *, raw_ostream &OS) {
  69     return ScalarTraits<StringValue>::output(S, nullptr, OS);
  70   }
  71
  72   static StringRef input(StringRef Scalar, void *Ctx, FlowStringValue &S) {
  73     return ScalarTraits<StringValue>::input(Scalar, Ctx, S);
  74   }
  75
  76   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   static void output(const BlockStringValue &S, void *Ctx, raw_ostream &OS) {
  89     return ScalarTraits<StringValue>::output(S.Value, Ctx, OS);
  90   }
  91
  92   static StringRef input(StringRef Scalar, void *Ctx, BlockStringValue &S) {
  93     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   UnsignedValue() = default;
 104   UnsignedValue(unsigned Value) : Value(Value) {}
 105
 106   bool operator==(const UnsignedValue &Other) const {
 107     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     return ScalarTraits<unsigned>::output(Value.Value, Ctx, OS);
 114   }
 115
 116   static StringRef input(StringRef Scalar, void *Ctx, UnsignedValue &Value) {
 117     if (const auto *Node =
 118             reinterpret_cast<yaml::Input *>(Ctx)->getCurrentNode())
 119       Value.SourceRange = Node->getSourceRange();
 120     return ScalarTraits<unsigned>::input(Scalar, Ctx, Value.Value);
 121   }
 122
 123   static QuotingType mustQuote(StringRef Scalar) {
 124     return ScalarTraits<unsigned>::mustQuote(Scalar);
 125   }
 126 };
 127
 128 template <> struct ScalarEnumerationTraits<MachineJumpTableInfo::JTEntryKind> {
 129   static void enumeration(yaml::IO &IO,
 130                           MachineJumpTableInfo::JTEntryKind &EntryKind) {
 131     IO.enumCase(EntryKind, "block-address",
 132                 MachineJumpTableInfo::EK_BlockAddress);
 133     IO.enumCase(EntryKind, "gp-rel64-block-address",
 134                 MachineJumpTableInfo::EK_GPRel64BlockAddress);
 135     IO.enumCase(EntryKind, "gp-rel32-block-address",
 136                 MachineJumpTableInfo::EK_GPRel32BlockAddress);
 137     IO.enumCase(EntryKind, "label-difference32",
 138                 MachineJumpTableInfo::EK_LabelDifference32);
 139     IO.enumCase(EntryKind, "inline", MachineJumpTableInfo::EK_Inline);
 140     IO.enumCase(EntryKind, "custom32", MachineJumpTableInfo::EK_Custom32);
 141   }
 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   bool operator==(const VirtualRegisterDefinition &Other) const {
 162     return ID == Other.ID && Class == Other.Class &&
 163            PreferredRegister == Other.PreferredRegister;
 164   }
 165 };
 166
 167 template <> struct MappingTraits<VirtualRegisterDefinition> {
 168   static void mapping(IO &YamlIO, VirtualRegisterDefinition &Reg) {
 169     YamlIO.mapRequired("id", Reg.ID);
 170     YamlIO.mapRequired("class", Reg.Class);
 171     YamlIO.mapOptional("preferred-register", Reg.PreferredRegister,
 172                        StringValue()); // Don't print out when it's empty.
 173   }
 174
 175   static const bool flow = true;
 176 };
 177
 178 struct MachineFunctionLiveIn {
 179   StringValue Register;
 180   StringValue VirtualRegister;
 181
 182   bool operator==(const MachineFunctionLiveIn &Other) const {
 183     return Register == Other.Register &&
 184            VirtualRegister == Other.VirtualRegister;
 185   }
 186 };
 187
 188 template <> struct MappingTraits<MachineFunctionLiveIn> {
 189   static void mapping(IO &YamlIO, MachineFunctionLiveIn &LiveIn) {
 190     YamlIO.mapRequired("reg", LiveIn.Register);
 191     YamlIO.mapOptional(
 192         "virtual-reg", LiveIn.VirtualRegister,
 193         StringValue()); // Don't print the virtual register when it's empty.
 194   }
 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   bool operator==(const MachineStackObject &Other) const {
 224     return ID == Other.ID && Name == Other.Name && Type == Other.Type &&
 225            Offset == Other.Offset && Size == Other.Size &&
 226            Alignment == Other.Alignment &&
 227            StackID == Other.StackID &&
 228            CalleeSavedRegister == Other.CalleeSavedRegister &&
 229            CalleeSavedRestored == Other.CalleeSavedRestored &&
 230            LocalOffset == Other.LocalOffset && DebugVar == Other.DebugVar &&
 231            DebugExpr == Other.DebugExpr && DebugLoc == Other.DebugLoc;
 232   }
 233 };
 234
 235 template <> struct ScalarEnumerationTraits<MachineStackObject::ObjectType> {
 236   static void enumeration(yaml::IO &IO, MachineStackObject::ObjectType &Type) {
 237     IO.enumCase(Type, "default", MachineStackObject::DefaultType);
 238     IO.enumCase(Type, "spill-slot", MachineStackObject::SpillSlot);
 239     IO.enumCase(Type, "variable-sized", MachineStackObject::VariableSized);
 240   }
 241 };
 242
 243 template <> struct MappingTraits<MachineStackObject> {
 244   static void mapping(yaml::IO &YamlIO, MachineStackObject &Object) {
 245     YamlIO.mapRequired("id", Object.ID);
 246     YamlIO.mapOptional("name", Object.Name,
 247                        StringValue()); // Don't print out an empty name.
 248     YamlIO.mapOptional(
 249         "type", Object.Type,
 250         MachineStackObject::DefaultType); // Don't print the default type.
 251     YamlIO.mapOptional("offset", Object.Offset, (int64_t)0);
 252     if (Object.Type != MachineStackObject::VariableSized)
 253       YamlIO.mapRequired("size", Object.Size);
 254     YamlIO.mapOptional("alignment", Object.Alignment, (unsigned)0);
 255     YamlIO.mapOptional("stack-id", Object.StackID);
 256     YamlIO.mapOptional("callee-saved-register", Object.CalleeSavedRegister,
 257                        StringValue()); // Don't print it out when it's empty.
 258     YamlIO.mapOptional("callee-saved-restored", Object.CalleeSavedRestored,
 259                        true);
 260     YamlIO.mapOptional("local-offset", Object.LocalOffset, Optional<int64_t>());
 261     YamlIO.mapOptional("debug-info-variable", Object.DebugVar,
 262                        StringValue()); // Don't print it out when it's empty.
 263     YamlIO.mapOptional("debug-info-expression", Object.DebugExpr,
 264                        StringValue()); // Don't print it out when it's empty.
 265     YamlIO.mapOptional("debug-info-location", Object.DebugLoc,
 266                        StringValue()); // Don't print it out when it's empty.
 267   }
 268
 269   static const bool flow = true;
 270 };
 271
 272 /// Serializable representation of the fixed stack object from the
 273 /// MachineFrameInfo class.
 274 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   bool operator==(const FixedMachineStackObject &Other) const {
 291     return ID == Other.ID && Type == Other.Type && Offset == Other.Offset &&
 292            Size == Other.Size && Alignment == Other.Alignment &&
 293            StackID == Other.StackID &&
 294            IsImmutable == Other.IsImmutable && IsAliased == Other.IsAliased &&
 295            CalleeSavedRegister == Other.CalleeSavedRegister &&
 296            CalleeSavedRestored == Other.CalleeSavedRestored &&
 297            DebugVar == Other.DebugVar && DebugExpr == Other.DebugExpr
 298            && DebugLoc == Other.DebugLoc;
 299   }
 300 };
 301
 302 template <>
 303 struct ScalarEnumerationTraits<FixedMachineStackObject::ObjectType> {
 304   static void enumeration(yaml::IO &IO,
 305                           FixedMachineStackObject::ObjectType &Type) {
 306     IO.enumCase(Type, "default", FixedMachineStackObject::DefaultType);
 307     IO.enumCase(Type, "spill-slot", FixedMachineStackObject::SpillSlot);
 308   }
 309 };
 310
 311 template <> struct MappingTraits<FixedMachineStackObject> {
 312   static void mapping(yaml::IO &YamlIO, FixedMachineStackObject &Object) {
 313     YamlIO.mapRequired("id", Object.ID);
 314     YamlIO.mapOptional(
 315         "type", Object.Type,
 316         FixedMachineStackObject::DefaultType); // Don't print the default type.
 317     YamlIO.mapOptional("offset", Object.Offset, (int64_t)0);
 318     YamlIO.mapOptional("size", Object.Size, (uint64_t)0);
 319     YamlIO.mapOptional("alignment", Object.Alignment, (unsigned)0);
 320     YamlIO.mapOptional("stack-id", Object.StackID);
 321     if (Object.Type != FixedMachineStackObject::SpillSlot) {
 322       YamlIO.mapOptional("isImmutable", Object.IsImmutable, false);
 323       YamlIO.mapOptional("isAliased", Object.IsAliased, false);
 324     }
 325     YamlIO.mapOptional("callee-saved-register", Object.CalleeSavedRegister,
 326                        StringValue()); // Don't print it out when it's empty.
 327     YamlIO.mapOptional("callee-saved-restored", Object.CalleeSavedRestored,
 328                      true);
 329     YamlIO.mapOptional("debug-info-variable", Object.DebugVar,
 330                        StringValue()); // Don't print it out when it's empty.
 331     YamlIO.mapOptional("debug-info-expression", Object.DebugExpr,
 332                        StringValue()); // Don't print it out when it's empty.
 333     YamlIO.mapOptional("debug-info-location", Object.DebugLoc,
 334                        StringValue()); // Don't print it out when it's empty.
 335   }
 336
 337   static const bool flow = true;
 338 };
 339
 340 struct MachineConstantPoolValue {
 341   UnsignedValue ID;
 342   StringValue Value;
 343   unsigned Alignment = 0;
 344   bool IsTargetSpecific = false;
 345
 346   bool operator==(const MachineConstantPoolValue &Other) const {
 347     return ID == Other.ID && Value == Other.Value &&
 348            Alignment == Other.Alignment &&
 349            IsTargetSpecific == Other.IsTargetSpecific;
 350   }
 351 };
 352
 353 template <> struct MappingTraits<MachineConstantPoolValue> {
 354   static void mapping(IO &YamlIO, MachineConstantPoolValue &Constant) {
 355     YamlIO.mapRequired("id", Constant.ID);
 356     YamlIO.mapOptional("value", Constant.Value, StringValue());
 357     YamlIO.mapOptional("alignment", Constant.Alignment, (unsigned)0);
 358     YamlIO.mapOptional("isTargetSpecific", Constant.IsTargetSpecific, false);
 359   }
 360 };
 361
 362 struct MachineJumpTable {
 363   struct Entry {
 364     UnsignedValue ID;
 365     std::vector<FlowStringValue> Blocks;
 366
 367     bool operator==(const Entry &Other) const {
 368       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     return Kind == Other.Kind && Entries == Other.Entries;
 377   }
 378 };
 379
 380 template <> struct MappingTraits<MachineJumpTable::Entry> {
 381   static void mapping(IO &YamlIO, MachineJumpTable::Entry &Entry) {
 382     YamlIO.mapRequired("id", Entry.ID);
 383     YamlIO.mapOptional("blocks", Entry.Blocks, std::vector<FlowStringValue>());
 384   }
 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   static void mapping(IO &YamlIO, MachineJumpTable &JT) {
 402     YamlIO.mapRequired("kind", JT.Kind);
 403     YamlIO.mapOptional("entries", JT.Entries,
 404                        std::vector<MachineJumpTable::Entry>());
 405   }
 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 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   bool operator==(const MachineFrameInfo &Other) const {
 436     return IsFrameAddressTaken == Other.IsFrameAddressTaken &&
 437            IsReturnAddressTaken == Other.IsReturnAddressTaken &&
 438            HasStackMap == Other.HasStackMap &&
 439            HasPatchPoint == Other.HasPatchPoint &&
 440            StackSize == Other.StackSize &&
 441            OffsetAdjustment == Other.OffsetAdjustment &&
 442            MaxAlignment == Other.MaxAlignment &&
 443            AdjustsStack == Other.AdjustsStack && HasCalls == Other.HasCalls &&
 444            StackProtector == Other.StackProtector &&
 445            MaxCallFrameSize == Other.MaxCallFrameSize &&
 446            HasOpaqueSPAdjustment == Other.HasOpaqueSPAdjustment &&
 447            HasVAStart == Other.HasVAStart &&
 448            HasMustTailInVarArgFunc == Other.HasMustTailInVarArgFunc &&
 449            LocalFrameSize == Other.LocalFrameSize &&
 450            SavePoint == Other.SavePoint && RestorePoint == Other.RestorePoint;
 451   }
 452 };
 453
 454 template <> struct MappingTraits<MachineFrameInfo> {
 455   static void mapping(IO &YamlIO, MachineFrameInfo &MFI) {
 456     YamlIO.mapOptional("isFrameAddressTaken", MFI.IsFrameAddressTaken, false);
 457     YamlIO.mapOptional("isReturnAddressTaken", MFI.IsReturnAddressTaken, false);
 458     YamlIO.mapOptional("hasStackMap", MFI.HasStackMap, false);
 459     YamlIO.mapOptional("hasPatchPoint", MFI.HasPatchPoint, false);
 460     YamlIO.mapOptional("stackSize", MFI.StackSize, (uint64_t)0);
 461     YamlIO.mapOptional("offsetAdjustment", MFI.OffsetAdjustment, (int)0);
 462     YamlIO.mapOptional("maxAlignment", MFI.MaxAlignment, (unsigned)0);
 463     YamlIO.mapOptional("adjustsStack", MFI.AdjustsStack, false);
 464     YamlIO.mapOptional("hasCalls", MFI.HasCalls, false);
 465     YamlIO.mapOptional("stackProtector", MFI.StackProtector,
 466                        StringValue()); // Don't print it out when it's empty.
 467     YamlIO.mapOptional("maxCallFrameSize", MFI.MaxCallFrameSize, (unsigned)~0);
 468     YamlIO.mapOptional("hasOpaqueSPAdjustment", MFI.HasOpaqueSPAdjustment,
 469                        false);
 470     YamlIO.mapOptional("hasVAStart", MFI.HasVAStart, false);
 471     YamlIO.mapOptional("hasMustTailInVarArgFunc", MFI.HasMustTailInVarArgFunc,
 472                        false);
 473     YamlIO.mapOptional("localFrameSize", MFI.LocalFrameSize, (unsigned)0);
 474     YamlIO.mapOptional("savePoint", MFI.SavePoint,
 475                        StringValue()); // Don't print it out when it's empty.
 476     YamlIO.mapOptional("restorePoint", MFI.RestorePoint,
 477                        StringValue()); // Don't print it out when it's empty.
 478   }
 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   static void mapping(IO &YamlIO, MachineFunction &MF) {
 507     YamlIO.mapRequired("name", MF.Name);
 508     YamlIO.mapOptional("alignment", MF.Alignment, (unsigned)0);
 509     YamlIO.mapOptional("exposesReturnsTwice", MF.ExposesReturnsTwice, false);
 510     YamlIO.mapOptional("legalized", MF.Legalized, false);
 511     YamlIO.mapOptional("regBankSelected", MF.RegBankSelected, false);
 512     YamlIO.mapOptional("selected", MF.Selected, false);
 513     YamlIO.mapOptional("failedISel", MF.FailedISel, false);
 514     YamlIO.mapOptional("tracksRegLiveness", MF.TracksRegLiveness, false);
 515     YamlIO.mapOptional("registers", MF.VirtualRegisters,
 516                        std::vector<VirtualRegisterDefinition>());
 517     YamlIO.mapOptional("liveins", MF.LiveIns,
 518                        std::vector<MachineFunctionLiveIn>());
 519     YamlIO.mapOptional("calleeSavedRegisters", MF.CalleeSavedRegisters,
 520                        Optional<std::vector<FlowStringValue>>());
 521     YamlIO.mapOptional("frameInfo", MF.FrameInfo, MachineFrameInfo());
 522     YamlIO.mapOptional("fixedStack", MF.FixedStackObjects,
 523                        std::vector<FixedMachineStackObject>());
 524     YamlIO.mapOptional("stack", MF.StackObjects,
 525                        std::vector<MachineStackObject>());
 526     YamlIO.mapOptional("constants", MF.Constants,
 527                        std::vector<MachineConstantPoolValue>());
 528     if (!YamlIO.outputting() || !MF.JumpTableInfo.Entries.empty())
 529       YamlIO.mapOptional("jumpTable", MF.JumpTableInfo, MachineJumpTable());
 530     YamlIO.mapOptional("body", MF.Body, BlockStringValue());
 531   }
 532 };
 533
 534 } // end namespace yaml
 535 } // end namespace llvm
 536
 537 #endif // LLVM_CODEGEN_MIRYAMLMAPPING_H