1 //===- MIRYAMLMapping.h - Describes the mapping between MIR and YAML ------===//
3 // The LLVM Compiler Infrastructure
5 // This file is distributed under the University of Illinois Open Source
6 // License. See LICENSE.TXT for details.
8 //===----------------------------------------------------------------------===//
10 // This file implements the mapping between various MIR data structures and
11 // their corresponding YAML representation.
13 //===----------------------------------------------------------------------===//
15 #ifndef LLVM_CODEGEN_MIRYAMLMAPPING_H
16 #define LLVM_CODEGEN_MIRYAMLMAPPING_H
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"
32 /// A wrapper around std::string which contains a source range that's being
33 /// set during parsing.
38 StringValue() = default;
39 StringValue(std::string Value) : Value(std::move(Value)) {}
41 bool operator==(const StringValue &Other) const {
42 return Value == Other.Value;
46 template <> struct ScalarTraits<StringValue> {
47 static void output(const StringValue &S, void *, raw_ostream &OS) {
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();
59 static QuotingType mustQuote(StringRef S) { return needsQuotes(S); }
62 struct FlowStringValue : StringValue {
63 FlowStringValue() = default;
64 FlowStringValue(std::string Value) : StringValue(std::move(Value)) {}
67 template <> struct ScalarTraits<FlowStringValue> {
68 static void output(const FlowStringValue &S, void *, raw_ostream &OS) {
69 return ScalarTraits<StringValue>::output(S, nullptr, OS);
72 static StringRef input(StringRef Scalar, void *Ctx, FlowStringValue &S) {
73 return ScalarTraits<StringValue>::input(Scalar, Ctx, S);
76 static QuotingType mustQuote(StringRef S) { return needsQuotes(S); }
79 struct BlockStringValue {
82 bool operator==(const BlockStringValue &Other) const {
83 return Value == Other.Value;
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);
92 static StringRef input(StringRef Scalar, void *Ctx, BlockStringValue &S) {
93 return ScalarTraits<StringValue>::input(Scalar, Ctx, S.Value);
97 /// A wrapper around unsigned which contains a source range that's being set
99 struct UnsignedValue {
103 UnsignedValue() = default;
104 UnsignedValue(unsigned Value) : Value(Value) {}
106 bool operator==(const UnsignedValue &Other) const {
107 return Value == Other.Value;
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);
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);
123 static QuotingType mustQuote(StringRef Scalar) {
124 return ScalarTraits<unsigned>::mustQuote(Scalar);
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);
144 } // end namespace yaml
145 } // end namespace llvm
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)
154 struct VirtualRegisterDefinition {
157 StringValue PreferredRegister;
159 // TODO: Serialize the target specific register hints.
161 bool operator==(const VirtualRegisterDefinition &Other) const {
162 return ID == Other.ID && Class == Other.Class &&
163 PreferredRegister == Other.PreferredRegister;
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.
175 static const bool flow = true;
178 struct MachineFunctionLiveIn {
179 StringValue Register;
180 StringValue VirtualRegister;
182 bool operator==(const MachineFunctionLiveIn &Other) const {
183 return Register == Other.Register &&
184 VirtualRegister == Other.VirtualRegister;
188 template <> struct MappingTraits<MachineFunctionLiveIn> {
189 static void mapping(IO &YamlIO, MachineFunctionLiveIn &LiveIn) {
190 YamlIO.mapRequired("reg", LiveIn.Register);
192 "virtual-reg", LiveIn.VirtualRegister,
193 StringValue()); // Don't print the virtual register when it's empty.
196 static const bool flow = true;
199 /// Serializable representation of stack object from the MachineFrameInfo class.
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.
205 /// The 'isPreallocated' flag is determined by the local offset.
206 struct MachineStackObject {
207 enum ObjectType { DefaultType, SpillSlot, VariableSized };
210 // TODO: Serialize unnamed LLVM alloca reference.
211 ObjectType Type = DefaultType;
214 unsigned Alignment = 0;
216 StringValue CalleeSavedRegister;
217 bool CalleeSavedRestored = true;
218 Optional<int64_t> LocalOffset;
219 StringValue DebugVar;
220 StringValue DebugExpr;
221 StringValue DebugLoc;
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;
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);
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.
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,
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.
269 static const bool flow = true;
272 /// Serializable representation of the fixed stack object from the
273 /// MachineFrameInfo class.
274 struct FixedMachineStackObject {
275 enum ObjectType { DefaultType, SpillSlot };
277 ObjectType Type = DefaultType;
280 unsigned Alignment = 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;
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;
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);
311 template <> struct MappingTraits<FixedMachineStackObject> {
312 static void mapping(yaml::IO &YamlIO, FixedMachineStackObject &Object) {
313 YamlIO.mapRequired("id", Object.ID);
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);
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,
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.
337 static const bool flow = true;
340 struct MachineConstantPoolValue {
343 unsigned Alignment = 0;
344 bool IsTargetSpecific = false;
346 bool operator==(const MachineConstantPoolValue &Other) const {
347 return ID == Other.ID && Value == Other.Value &&
348 Alignment == Other.Alignment &&
349 IsTargetSpecific == Other.IsTargetSpecific;
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);
362 struct MachineJumpTable {
365 std::vector<FlowStringValue> Blocks;
367 bool operator==(const Entry &Other) const {
368 return ID == Other.ID && Blocks == Other.Blocks;
372 MachineJumpTableInfo::JTEntryKind Kind = MachineJumpTableInfo::EK_Custom32;
373 std::vector<Entry> Entries;
375 bool operator==(const MachineJumpTable &Other) const {
376 return Kind == Other.Kind && Entries == Other.Entries;
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>());
387 } // end namespace yaml
388 } // end namespace llvm
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)
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>());
408 /// Serializable representation of MachineFrameInfo.
410 /// Doesn't serialize attributes like 'StackAlignment', 'IsStackRealignable' and
411 /// 'RealignOption' as they are determined by the target and LLVM function
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 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;
436 bool operator==(const MachineFrameInfo &Other) const {
437 return IsFrameAddressTaken == Other.IsFrameAddressTaken &&
438 IsReturnAddressTaken == Other.IsReturnAddressTaken &&
439 HasStackMap == Other.HasStackMap &&
440 HasPatchPoint == Other.HasPatchPoint &&
441 StackSize == Other.StackSize &&
442 OffsetAdjustment == Other.OffsetAdjustment &&
443 MaxAlignment == Other.MaxAlignment &&
444 AdjustsStack == Other.AdjustsStack && HasCalls == Other.HasCalls &&
445 StackProtector == Other.StackProtector &&
446 MaxCallFrameSize == Other.MaxCallFrameSize &&
447 CVBytesOfCalleeSavedRegisters ==
448 Other.CVBytesOfCalleeSavedRegisters &&
449 HasOpaqueSPAdjustment == Other.HasOpaqueSPAdjustment &&
450 HasVAStart == Other.HasVAStart &&
451 HasMustTailInVarArgFunc == Other.HasMustTailInVarArgFunc &&
452 LocalFrameSize == Other.LocalFrameSize &&
453 SavePoint == Other.SavePoint && RestorePoint == Other.RestorePoint;
457 template <> struct MappingTraits<MachineFrameInfo> {
458 static void mapping(IO &YamlIO, MachineFrameInfo &MFI) {
459 YamlIO.mapOptional("isFrameAddressTaken", MFI.IsFrameAddressTaken, false);
460 YamlIO.mapOptional("isReturnAddressTaken", MFI.IsReturnAddressTaken, false);
461 YamlIO.mapOptional("hasStackMap", MFI.HasStackMap, false);
462 YamlIO.mapOptional("hasPatchPoint", MFI.HasPatchPoint, false);
463 YamlIO.mapOptional("stackSize", MFI.StackSize, (uint64_t)0);
464 YamlIO.mapOptional("offsetAdjustment", MFI.OffsetAdjustment, (int)0);
465 YamlIO.mapOptional("maxAlignment", MFI.MaxAlignment, (unsigned)0);
466 YamlIO.mapOptional("adjustsStack", MFI.AdjustsStack, false);
467 YamlIO.mapOptional("hasCalls", MFI.HasCalls, false);
468 YamlIO.mapOptional("stackProtector", MFI.StackProtector,
469 StringValue()); // Don't print it out when it's empty.
470 YamlIO.mapOptional("maxCallFrameSize", MFI.MaxCallFrameSize, (unsigned)~0);
471 YamlIO.mapOptional("cvBytesOfCalleeSavedRegisters",
472 MFI.CVBytesOfCalleeSavedRegisters, 0U);
473 YamlIO.mapOptional("hasOpaqueSPAdjustment", MFI.HasOpaqueSPAdjustment,
475 YamlIO.mapOptional("hasVAStart", MFI.HasVAStart, false);
476 YamlIO.mapOptional("hasMustTailInVarArgFunc", MFI.HasMustTailInVarArgFunc,
478 YamlIO.mapOptional("localFrameSize", MFI.LocalFrameSize, (unsigned)0);
479 YamlIO.mapOptional("savePoint", MFI.SavePoint,
480 StringValue()); // Don't print it out when it's empty.
481 YamlIO.mapOptional("restorePoint", MFI.RestorePoint,
482 StringValue()); // Don't print it out when it's empty.
486 struct MachineFunction {
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 bool HasWinCFI = false;
498 std::vector<VirtualRegisterDefinition> VirtualRegisters;
499 std::vector<MachineFunctionLiveIn> LiveIns;
500 Optional<std::vector<FlowStringValue>> CalleeSavedRegisters;
501 // TODO: Serialize the various register masks.
503 MachineFrameInfo FrameInfo;
504 std::vector<FixedMachineStackObject> FixedStackObjects;
505 std::vector<MachineStackObject> StackObjects;
506 std::vector<MachineConstantPoolValue> Constants; /// Constant pool.
507 MachineJumpTable JumpTableInfo;
508 BlockStringValue Body;
511 template <> struct MappingTraits<MachineFunction> {
512 static void mapping(IO &YamlIO, MachineFunction &MF) {
513 YamlIO.mapRequired("name", MF.Name);
514 YamlIO.mapOptional("alignment", MF.Alignment, (unsigned)0);
515 YamlIO.mapOptional("exposesReturnsTwice", MF.ExposesReturnsTwice, false);
516 YamlIO.mapOptional("legalized", MF.Legalized, false);
517 YamlIO.mapOptional("regBankSelected", MF.RegBankSelected, false);
518 YamlIO.mapOptional("selected", MF.Selected, false);
519 YamlIO.mapOptional("failedISel", MF.FailedISel, false);
520 YamlIO.mapOptional("tracksRegLiveness", MF.TracksRegLiveness, false);
521 YamlIO.mapOptional("hasWinCFI", MF.HasWinCFI, false);
522 YamlIO.mapOptional("registers", MF.VirtualRegisters,
523 std::vector<VirtualRegisterDefinition>());
524 YamlIO.mapOptional("liveins", MF.LiveIns,
525 std::vector<MachineFunctionLiveIn>());
526 YamlIO.mapOptional("calleeSavedRegisters", MF.CalleeSavedRegisters,
527 Optional<std::vector<FlowStringValue>>());
528 YamlIO.mapOptional("frameInfo", MF.FrameInfo, MachineFrameInfo());
529 YamlIO.mapOptional("fixedStack", MF.FixedStackObjects,
530 std::vector<FixedMachineStackObject>());
531 YamlIO.mapOptional("stack", MF.StackObjects,
532 std::vector<MachineStackObject>());
533 YamlIO.mapOptional("constants", MF.Constants,
534 std::vector<MachineConstantPoolValue>());
535 if (!YamlIO.outputting() || !MF.JumpTableInfo.Entries.empty())
536 YamlIO.mapOptional("jumpTable", MF.JumpTableInfo, MachineJumpTable());
537 YamlIO.mapOptional("body", MF.Body, BlockStringValue());
541 } // end namespace yaml
542 } // end namespace llvm
544 #endif // LLVM_CODEGEN_MIRYAMLMAPPING_H