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 // The MIR serialization library is currently a work in progress. It can't
  11 // serialize machine functions at this time.
  12 //
  13 // This file implements the mapping between various MIR data structures and
  14 // their corresponding YAML representation.
  15 //
  16 //===----------------------------------------------------------------------===//
  17
  18 #ifndef LLVM_LIB_CODEGEN_MIRYAMLMAPPING_H
  19 #define LLVM_LIB_CODEGEN_MIRYAMLMAPPING_H
  20
  21 #include "llvm/ADT/StringRef.h"
  22 #include "llvm/CodeGen/MachineJumpTableInfo.h"
  23 #include "llvm/Support/YAMLTraits.h"
  24 #include <vector>
  25
  26 namespace llvm {
  27 namespace yaml {
  28
  29 /// A wrapper around std::string which contains a source range that's being
  30 /// set during parsing.
  31 struct StringValue {
  32   std::string Value;
  33   SMRange SourceRange;
  34
  35   StringValue() {}
  36   StringValue(std::string Value) : Value(std::move(Value)) {}
  37
  38   bool operator==(const StringValue &Other) const {
  39     return Value == Other.Value;
  40   }
  41 };
  42
  43 template <> struct ScalarTraits<StringValue> {
  44   static void output(const StringValue &S, void *, llvm::raw_ostream &OS) {
  45     OS << S.Value;
  46   }
  47
  48   static StringRef input(StringRef Scalar, void *Ctx, StringValue &S) {
  49     S.Value = Scalar.str();
  50     if (const auto *Node =
  51             reinterpret_cast<yaml::Input *>(Ctx)->getCurrentNode())
  52       S.SourceRange = Node->getSourceRange();
  53     return "";
  54   }
  55
  56   static bool mustQuote(StringRef Scalar) { return needsQuotes(Scalar); }
  57 };
  58
  59 struct FlowStringValue : StringValue {
  60   FlowStringValue() {}
  61   FlowStringValue(std::string Value) : StringValue(Value) {}
  62 };
  63
  64 template <> struct ScalarTraits<FlowStringValue> {
  65   static void output(const FlowStringValue &S, void *, llvm::raw_ostream &OS) {
  66     return ScalarTraits<StringValue>::output(S, nullptr, OS);
  67   }
  68
  69   static StringRef input(StringRef Scalar, void *Ctx, FlowStringValue &S) {
  70     return ScalarTraits<StringValue>::input(Scalar, Ctx, S);
  71   }
  72
  73   static bool mustQuote(StringRef Scalar) { return needsQuotes(Scalar); }
  74 };
  75
  76 struct BlockStringValue {
  77   StringValue Value;
  78 };
  79
  80 template <> struct BlockScalarTraits<BlockStringValue> {
  81   static void output(const BlockStringValue &S, void *Ctx, raw_ostream &OS) {
  82     return ScalarTraits<StringValue>::output(S.Value, Ctx, OS);
  83   }
  84
  85   static StringRef input(StringRef Scalar, void *Ctx, BlockStringValue &S) {
  86     return ScalarTraits<StringValue>::input(Scalar, Ctx, S.Value);
  87   }
  88 };
  89
  90 /// A wrapper around unsigned which contains a source range that's being set
  91 /// during parsing.
  92 struct UnsignedValue {
  93   unsigned Value;
  94   SMRange SourceRange;
  95
  96   UnsignedValue() : Value(0) {}
  97   UnsignedValue(unsigned Value) : Value(Value) {}
  98
  99   bool operator==(const UnsignedValue &Other) const {
 100     return Value == Other.Value;
 101   }
 102 };
 103
 104 template <> struct ScalarTraits<UnsignedValue> {
 105   static void output(const UnsignedValue &Value, void *Ctx, raw_ostream &OS) {
 106     return ScalarTraits<unsigned>::output(Value.Value, Ctx, OS);
 107   }
 108
 109   static StringRef input(StringRef Scalar, void *Ctx, UnsignedValue &Value) {
 110     if (const auto *Node =
 111             reinterpret_cast<yaml::Input *>(Ctx)->getCurrentNode())
 112       Value.SourceRange = Node->getSourceRange();
 113     return ScalarTraits<unsigned>::input(Scalar, Ctx, Value.Value);
 114   }
 115
 116   static bool mustQuote(StringRef Scalar) {
 117     return ScalarTraits<unsigned>::mustQuote(Scalar);
 118   }
 119 };
 120
 121 template <> struct ScalarEnumerationTraits<MachineJumpTableInfo::JTEntryKind> {
 122   static void enumeration(yaml::IO &IO,
 123                           MachineJumpTableInfo::JTEntryKind &EntryKind) {
 124     IO.enumCase(EntryKind, "block-address",
 125                 MachineJumpTableInfo::EK_BlockAddress);
 126     IO.enumCase(EntryKind, "gp-rel64-block-address",
 127                 MachineJumpTableInfo::EK_GPRel64BlockAddress);
 128     IO.enumCase(EntryKind, "gp-rel32-block-address",
 129                 MachineJumpTableInfo::EK_GPRel32BlockAddress);
 130     IO.enumCase(EntryKind, "label-difference32",
 131                 MachineJumpTableInfo::EK_LabelDifference32);
 132     IO.enumCase(EntryKind, "inline", MachineJumpTableInfo::EK_Inline);
 133     IO.enumCase(EntryKind, "custom32", MachineJumpTableInfo::EK_Custom32);
 134   }
 135 };
 136
 137 } // end namespace yaml
 138 } // end namespace llvm
 139
 140 LLVM_YAML_IS_SEQUENCE_VECTOR(llvm::yaml::StringValue)
 141 LLVM_YAML_IS_FLOW_SEQUENCE_VECTOR(llvm::yaml::FlowStringValue)
 142 LLVM_YAML_IS_FLOW_SEQUENCE_VECTOR(llvm::yaml::UnsignedValue)
 143
 144 namespace llvm {
 145 namespace yaml {
 146
 147 struct VirtualRegisterDefinition {
 148   UnsignedValue ID;
 149   StringValue Class;
 150   StringValue PreferredRegister;
 151   // TODO: Serialize the target specific register hints.
 152 };
 153
 154 template <> struct MappingTraits<VirtualRegisterDefinition> {
 155   static void mapping(IO &YamlIO, VirtualRegisterDefinition &Reg) {
 156     YamlIO.mapRequired("id", Reg.ID);
 157     YamlIO.mapRequired("class", Reg.Class);
 158     YamlIO.mapOptional("preferred-register", Reg.PreferredRegister,
 159                        StringValue()); // Don't print out when it's empty.
 160   }
 161
 162   static const bool flow = true;
 163 };
 164
 165 struct MachineFunctionLiveIn {
 166   StringValue Register;
 167   StringValue VirtualRegister;
 168 };
 169
 170 template <> struct MappingTraits<MachineFunctionLiveIn> {
 171   static void mapping(IO &YamlIO, MachineFunctionLiveIn &LiveIn) {
 172     YamlIO.mapRequired("reg", LiveIn.Register);
 173     YamlIO.mapOptional(
 174         "virtual-reg", LiveIn.VirtualRegister,
 175         StringValue()); // Don't print the virtual register when it's empty.
 176   }
 177
 178   static const bool flow = true;
 179 };
 180
 181 /// Serializable representation of stack object from the MachineFrameInfo class.
 182 ///
 183 /// The flags 'isImmutable' and 'isAliased' aren't serialized, as they are
 184 /// determined by the object's type and frame information flags.
 185 /// Dead stack objects aren't serialized.
 186 ///
 187 /// The 'isPreallocated' flag is determined by the local offset.
 188 struct MachineStackObject {
 189   enum ObjectType { DefaultType, SpillSlot, VariableSized };
 190   UnsignedValue ID;
 191   StringValue Name;
 192   // TODO: Serialize unnamed LLVM alloca reference.
 193   ObjectType Type = DefaultType;
 194   int64_t Offset = 0;
 195   uint64_t Size = 0;
 196   unsigned Alignment = 0;
 197   StringValue CalleeSavedRegister;
 198   Optional<int64_t> LocalOffset;
 199   StringValue DebugVar;
 200   StringValue DebugExpr;
 201   StringValue DebugLoc;
 202 };
 203
 204 template <> struct ScalarEnumerationTraits<MachineStackObject::ObjectType> {
 205   static void enumeration(yaml::IO &IO, MachineStackObject::ObjectType &Type) {
 206     IO.enumCase(Type, "default", MachineStackObject::DefaultType);
 207     IO.enumCase(Type, "spill-slot", MachineStackObject::SpillSlot);
 208     IO.enumCase(Type, "variable-sized", MachineStackObject::VariableSized);
 209   }
 210 };
 211
 212 template <> struct MappingTraits<MachineStackObject> {
 213   static void mapping(yaml::IO &YamlIO, MachineStackObject &Object) {
 214     YamlIO.mapRequired("id", Object.ID);
 215     YamlIO.mapOptional("name", Object.Name,
 216                        StringValue()); // Don't print out an empty name.
 217     YamlIO.mapOptional(
 218         "type", Object.Type,
 219         MachineStackObject::DefaultType); // Don't print the default type.
 220     YamlIO.mapOptional("offset", Object.Offset);
 221     if (Object.Type != MachineStackObject::VariableSized)
 222       YamlIO.mapRequired("size", Object.Size);
 223     YamlIO.mapOptional("alignment", Object.Alignment);
 224     YamlIO.mapOptional("callee-saved-register", Object.CalleeSavedRegister,
 225                        StringValue()); // Don't print it out when it's empty.
 226     YamlIO.mapOptional("local-offset", Object.LocalOffset);
 227     YamlIO.mapOptional("di-variable", Object.DebugVar,
 228                        StringValue()); // Don't print it out when it's empty.
 229     YamlIO.mapOptional("di-expression", Object.DebugExpr,
 230                        StringValue()); // Don't print it out when it's empty.
 231     YamlIO.mapOptional("di-location", Object.DebugLoc,
 232                        StringValue()); // Don't print it out when it's empty.
 233   }
 234
 235   static const bool flow = true;
 236 };
 237
 238 /// Serializable representation of the fixed stack object from the
 239 /// MachineFrameInfo class.
 240 struct FixedMachineStackObject {
 241   enum ObjectType { DefaultType, SpillSlot };
 242   UnsignedValue ID;
 243   ObjectType Type = DefaultType;
 244   int64_t Offset = 0;
 245   uint64_t Size = 0;
 246   unsigned Alignment = 0;
 247   bool IsImmutable = false;
 248   bool IsAliased = false;
 249   StringValue CalleeSavedRegister;
 250 };
 251
 252 template <>
 253 struct ScalarEnumerationTraits<FixedMachineStackObject::ObjectType> {
 254   static void enumeration(yaml::IO &IO,
 255                           FixedMachineStackObject::ObjectType &Type) {
 256     IO.enumCase(Type, "default", FixedMachineStackObject::DefaultType);
 257     IO.enumCase(Type, "spill-slot", FixedMachineStackObject::SpillSlot);
 258   }
 259 };
 260
 261 template <> struct MappingTraits<FixedMachineStackObject> {
 262   static void mapping(yaml::IO &YamlIO, FixedMachineStackObject &Object) {
 263     YamlIO.mapRequired("id", Object.ID);
 264     YamlIO.mapOptional(
 265         "type", Object.Type,
 266         FixedMachineStackObject::DefaultType); // Don't print the default type.
 267     YamlIO.mapOptional("offset", Object.Offset);
 268     YamlIO.mapOptional("size", Object.Size);
 269     YamlIO.mapOptional("alignment", Object.Alignment);
 270     if (Object.Type != FixedMachineStackObject::SpillSlot) {
 271       YamlIO.mapOptional("isImmutable", Object.IsImmutable);
 272       YamlIO.mapOptional("isAliased", Object.IsAliased);
 273     }
 274     YamlIO.mapOptional("callee-saved-register", Object.CalleeSavedRegister,
 275                        StringValue()); // Don't print it out when it's empty.
 276   }
 277
 278   static const bool flow = true;
 279 };
 280
 281 struct MachineConstantPoolValue {
 282   UnsignedValue ID;
 283   StringValue Value;
 284   unsigned Alignment = 0;
 285 };
 286
 287 template <> struct MappingTraits<MachineConstantPoolValue> {
 288   static void mapping(IO &YamlIO, MachineConstantPoolValue &Constant) {
 289     YamlIO.mapRequired("id", Constant.ID);
 290     YamlIO.mapOptional("value", Constant.Value);
 291     YamlIO.mapOptional("alignment", Constant.Alignment);
 292   }
 293 };
 294
 295 struct MachineJumpTable {
 296   struct Entry {
 297     UnsignedValue ID;
 298     std::vector<FlowStringValue> Blocks;
 299   };
 300
 301   MachineJumpTableInfo::JTEntryKind Kind = MachineJumpTableInfo::EK_Custom32;
 302   std::vector<Entry> Entries;
 303 };
 304
 305 template <> struct MappingTraits<MachineJumpTable::Entry> {
 306   static void mapping(IO &YamlIO, MachineJumpTable::Entry &Entry) {
 307     YamlIO.mapRequired("id", Entry.ID);
 308     YamlIO.mapOptional("blocks", Entry.Blocks);
 309   }
 310 };
 311
 312 } // end namespace yaml
 313 } // end namespace llvm
 314
 315 LLVM_YAML_IS_SEQUENCE_VECTOR(llvm::yaml::MachineFunctionLiveIn)
 316 LLVM_YAML_IS_SEQUENCE_VECTOR(llvm::yaml::VirtualRegisterDefinition)
 317 LLVM_YAML_IS_SEQUENCE_VECTOR(llvm::yaml::MachineStackObject)
 318 LLVM_YAML_IS_SEQUENCE_VECTOR(llvm::yaml::FixedMachineStackObject)
 319 LLVM_YAML_IS_SEQUENCE_VECTOR(llvm::yaml::MachineConstantPoolValue)
 320 LLVM_YAML_IS_SEQUENCE_VECTOR(llvm::yaml::MachineJumpTable::Entry)
 321
 322 namespace llvm {
 323 namespace yaml {
 324
 325 template <> struct MappingTraits<MachineJumpTable> {
 326   static void mapping(IO &YamlIO, MachineJumpTable &JT) {
 327     YamlIO.mapRequired("kind", JT.Kind);
 328     YamlIO.mapOptional("entries", JT.Entries);
 329   }
 330 };
 331
 332 /// Serializable representation of MachineFrameInfo.
 333 ///
 334 /// Doesn't serialize attributes like 'StackAlignment', 'IsStackRealignable' and
 335 /// 'RealignOption' as they are determined by the target and LLVM function
 336 /// attributes.
 337 /// It also doesn't serialize attributes like 'NumFixedObject' and
 338 /// 'HasVarSizedObjects' as they are determined by the frame objects themselves.
 339 struct MachineFrameInfo {
 340   bool IsFrameAddressTaken = false;
 341   bool IsReturnAddressTaken = false;
 342   bool HasStackMap = false;
 343   bool HasPatchPoint = false;
 344   uint64_t StackSize = 0;
 345   int OffsetAdjustment = 0;
 346   unsigned MaxAlignment = 0;
 347   bool AdjustsStack = false;
 348   bool HasCalls = false;
 349   StringValue StackProtector;
 350   // TODO: Serialize FunctionContextIdx
 351   unsigned MaxCallFrameSize = 0;
 352   bool HasOpaqueSPAdjustment = false;
 353   bool HasVAStart = false;
 354   bool HasMustTailInVarArgFunc = false;
 355   StringValue SavePoint;
 356   StringValue RestorePoint;
 357 };
 358
 359 template <> struct MappingTraits<MachineFrameInfo> {
 360   static void mapping(IO &YamlIO, MachineFrameInfo &MFI) {
 361     YamlIO.mapOptional("isFrameAddressTaken", MFI.IsFrameAddressTaken);
 362     YamlIO.mapOptional("isReturnAddressTaken", MFI.IsReturnAddressTaken);
 363     YamlIO.mapOptional("hasStackMap", MFI.HasStackMap);
 364     YamlIO.mapOptional("hasPatchPoint", MFI.HasPatchPoint);
 365     YamlIO.mapOptional("stackSize", MFI.StackSize);
 366     YamlIO.mapOptional("offsetAdjustment", MFI.OffsetAdjustment);
 367     YamlIO.mapOptional("maxAlignment", MFI.MaxAlignment);
 368     YamlIO.mapOptional("adjustsStack", MFI.AdjustsStack);
 369     YamlIO.mapOptional("hasCalls", MFI.HasCalls);
 370     YamlIO.mapOptional("stackProtector", MFI.StackProtector,
 371                        StringValue()); // Don't print it out when it's empty.
 372     YamlIO.mapOptional("maxCallFrameSize", MFI.MaxCallFrameSize);
 373     YamlIO.mapOptional("hasOpaqueSPAdjustment", MFI.HasOpaqueSPAdjustment);
 374     YamlIO.mapOptional("hasVAStart", MFI.HasVAStart);
 375     YamlIO.mapOptional("hasMustTailInVarArgFunc", MFI.HasMustTailInVarArgFunc);
 376     YamlIO.mapOptional("savePoint", MFI.SavePoint,
 377                        StringValue()); // Don't print it out when it's empty.
 378     YamlIO.mapOptional("restorePoint", MFI.RestorePoint,
 379                        StringValue()); // Don't print it out when it's empty.
 380   }
 381 };
 382
 383 struct MachineFunction {
 384   StringRef Name;
 385   unsigned Alignment = 0;
 386   bool ExposesReturnsTwice = false;
 387   bool HasInlineAsm = false;
 388   // Register information
 389   bool IsSSA = false;
 390   bool TracksRegLiveness = false;
 391   bool TracksSubRegLiveness = false;
 392   std::vector<VirtualRegisterDefinition> VirtualRegisters;
 393   std::vector<MachineFunctionLiveIn> LiveIns;
 394   Optional<std::vector<FlowStringValue>> CalleeSavedRegisters;
 395   // TODO: Serialize the various register masks.
 396   // Frame information
 397   MachineFrameInfo FrameInfo;
 398   std::vector<FixedMachineStackObject> FixedStackObjects;
 399   std::vector<MachineStackObject> StackObjects;
 400   std::vector<MachineConstantPoolValue> Constants; /// Constant pool.
 401   MachineJumpTable JumpTableInfo;
 402   BlockStringValue Body;
 403 };
 404
 405 template <> struct MappingTraits<MachineFunction> {
 406   static void mapping(IO &YamlIO, MachineFunction &MF) {
 407     YamlIO.mapRequired("name", MF.Name);
 408     YamlIO.mapOptional("alignment", MF.Alignment);
 409     YamlIO.mapOptional("exposesReturnsTwice", MF.ExposesReturnsTwice);
 410     YamlIO.mapOptional("hasInlineAsm", MF.HasInlineAsm);
 411     YamlIO.mapOptional("isSSA", MF.IsSSA);
 412     YamlIO.mapOptional("tracksRegLiveness", MF.TracksRegLiveness);
 413     YamlIO.mapOptional("tracksSubRegLiveness", MF.TracksSubRegLiveness);
 414     YamlIO.mapOptional("registers", MF.VirtualRegisters);
 415     YamlIO.mapOptional("liveins", MF.LiveIns);
 416     YamlIO.mapOptional("calleeSavedRegisters", MF.CalleeSavedRegisters);
 417     YamlIO.mapOptional("frameInfo", MF.FrameInfo);
 418     YamlIO.mapOptional("fixedStack", MF.FixedStackObjects);
 419     YamlIO.mapOptional("stack", MF.StackObjects);
 420     YamlIO.mapOptional("constants", MF.Constants);
 421     if (!YamlIO.outputting() || !MF.JumpTableInfo.Entries.empty())
 422       YamlIO.mapOptional("jumpTable", MF.JumpTableInfo);
 423     YamlIO.mapOptional("body", MF.Body);
 424   }
 425 };
 426
 427 } // end namespace yaml
 428 } // end namespace llvm
 429
 430 #endif