[llvm] r302985 - This reverts r302984

Vivek Pandya via llvm-commits llvm-commits at lists.llvm.org
Sat May 13 03:59:05 PDT 2017


Author: vivekvpandya
Date: Sat May 13 05:59:05 2017
New Revision: 302985

URL: http://llvm.org/viewvc/llvm-project?rev=302985&view=rev
Log:
This reverts r302984

Modified:
    llvm/trunk/include/llvm/CodeGen/MIRYamlMapping.h
    llvm/trunk/lib/CodeGen/MIRPrinter.cpp

Modified: llvm/trunk/include/llvm/CodeGen/MIRYamlMapping.h
URL: http://llvm.org/viewvc/llvm-project/llvm/trunk/include/llvm/CodeGen/MIRYamlMapping.h?rev=302985&r1=302984&r2=302985&view=diff
==============================================================================
--- llvm/trunk/include/llvm/CodeGen/MIRYamlMapping.h (original)
+++ llvm/trunk/include/llvm/CodeGen/MIRYamlMapping.h Sat May 13 05:59:05 2017
@@ -72,9 +72,6 @@ template <> struct ScalarTraits<FlowStri
 
 struct BlockStringValue {
   StringValue Value;
-  bool operator==(const BlockStringValue &Other) const {
-    return Value == Other.Value;
-  }
 };
 
 template <> struct BlockScalarTraits<BlockStringValue> {
@@ -149,10 +146,6 @@ struct VirtualRegisterDefinition {
   StringValue Class;
   StringValue PreferredRegister;
   // TODO: Serialize the target specific register hints.
-  bool operator==(const VirtualRegisterDefinition &Other) const {
-    return ID == Other.ID && Class == Other.Class &&
-           PreferredRegister == Other.PreferredRegister;
-  }
 };
 
 template <> struct MappingTraits<VirtualRegisterDefinition> {
@@ -169,10 +162,6 @@ template <> struct MappingTraits<Virtual
 struct MachineFunctionLiveIn {
   StringValue Register;
   StringValue VirtualRegister;
-  bool operator==(const MachineFunctionLiveIn &Other) const {
-    return Register == Other.Register &&
-           VirtualRegister == Other.VirtualRegister;
-  }
 };
 
 template <> struct MappingTraits<MachineFunctionLiveIn> {
@@ -207,14 +196,6 @@ struct MachineStackObject {
   StringValue DebugVar;
   StringValue DebugExpr;
   StringValue DebugLoc;
-  bool operator==(const MachineStackObject &Other) const {
-    return ID == Other.ID && Name == Other.Name && Type == Other.Type &&
-           Offset == Other.Offset && Size == Other.Size &&
-           Alignment == Other.Alignment &&
-           CalleeSavedRegister == Other.CalleeSavedRegister &&
-           LocalOffset == Other.LocalOffset && DebugVar == Other.DebugVar &&
-           DebugExpr == Other.DebugExpr && DebugLoc == Other.DebugLoc;
-  }
 };
 
 template <> struct ScalarEnumerationTraits<MachineStackObject::ObjectType> {
@@ -233,13 +214,13 @@ template <> struct MappingTraits<Machine
     YamlIO.mapOptional(
         "type", Object.Type,
         MachineStackObject::DefaultType); // Don't print the default type.
-    YamlIO.mapOptional("offset", Object.Offset, 0LL);
+    YamlIO.mapOptional("offset", Object.Offset);
     if (Object.Type != MachineStackObject::VariableSized)
       YamlIO.mapRequired("size", Object.Size);
-    YamlIO.mapOptional("alignment", Object.Alignment, 0U);
+    YamlIO.mapOptional("alignment", Object.Alignment);
     YamlIO.mapOptional("callee-saved-register", Object.CalleeSavedRegister,
                        StringValue()); // Don't print it out when it's empty.
-    YamlIO.mapOptional("local-offset", Object.LocalOffset, Optional<int64_t>());
+    YamlIO.mapOptional("local-offset", Object.LocalOffset);
     YamlIO.mapOptional("di-variable", Object.DebugVar,
                        StringValue()); // Don't print it out when it's empty.
     YamlIO.mapOptional("di-expression", Object.DebugExpr,
@@ -263,12 +244,6 @@ struct FixedMachineStackObject {
   bool IsImmutable = false;
   bool IsAliased = false;
   StringValue CalleeSavedRegister;
-  bool operator==(const FixedMachineStackObject &Other) const {
-    return ID == Other.ID && Type == Other.Type && Offset == Other.Offset &&
-           Size == Other.Size && Alignment == Other.Alignment &&
-           IsImmutable == Other.IsImmutable && IsAliased == Other.IsAliased &&
-           CalleeSavedRegister == Other.CalleeSavedRegister;
-  }
 };
 
 template <>
@@ -286,12 +261,12 @@ template <> struct MappingTraits<FixedMa
     YamlIO.mapOptional(
         "type", Object.Type,
         FixedMachineStackObject::DefaultType); // Don't print the default type.
-    YamlIO.mapOptional("offset", Object.Offset, 0LL);
-    YamlIO.mapOptional("size", Object.Size, 0ULL);
-    YamlIO.mapOptional("alignment", Object.Alignment, 0U);
+    YamlIO.mapOptional("offset", Object.Offset);
+    YamlIO.mapOptional("size", Object.Size);
+    YamlIO.mapOptional("alignment", Object.Alignment);
     if (Object.Type != FixedMachineStackObject::SpillSlot) {
-      YamlIO.mapOptional("isImmutable", Object.IsImmutable, false);
-      YamlIO.mapOptional("isAliased", Object.IsAliased, false);
+      YamlIO.mapOptional("isImmutable", Object.IsImmutable);
+      YamlIO.mapOptional("isAliased", Object.IsAliased);
     }
     YamlIO.mapOptional("callee-saved-register", Object.CalleeSavedRegister,
                        StringValue()); // Don't print it out when it's empty.
@@ -304,17 +279,13 @@ struct MachineConstantPoolValue {
   UnsignedValue ID;
   StringValue Value;
   unsigned Alignment = 0;
-  bool operator==(const MachineConstantPoolValue &Other) const {
-    return ID == Other.ID && Value == Other.Value &&
-           Alignment == Other.Alignment;
-  }
 };
 
 template <> struct MappingTraits<MachineConstantPoolValue> {
   static void mapping(IO &YamlIO, MachineConstantPoolValue &Constant) {
     YamlIO.mapRequired("id", Constant.ID);
-    YamlIO.mapOptional("value", Constant.Value, StringValue());
-    YamlIO.mapOptional("alignment", Constant.Alignment, 0U);
+    YamlIO.mapOptional("value", Constant.Value);
+    YamlIO.mapOptional("alignment", Constant.Alignment);
   }
 };
 
@@ -322,22 +293,16 @@ struct MachineJumpTable {
   struct Entry {
     UnsignedValue ID;
     std::vector<FlowStringValue> Blocks;
-    bool operator==(const Entry &Other) const {
-      return ID == Other.ID && Blocks == Other.Blocks;
-    }
   };
 
   MachineJumpTableInfo::JTEntryKind Kind = MachineJumpTableInfo::EK_Custom32;
   std::vector<Entry> Entries;
-  bool operator==(const MachineJumpTable &Other) const {
-    return Kind == Other.Kind && Entries == Other.Entries;
-  }
 };
 
 template <> struct MappingTraits<MachineJumpTable::Entry> {
   static void mapping(IO &YamlIO, MachineJumpTable::Entry &Entry) {
     YamlIO.mapRequired("id", Entry.ID);
-    YamlIO.mapOptional("blocks", Entry.Blocks, std::vector<FlowStringValue>());
+    YamlIO.mapOptional("blocks", Entry.Blocks);
   }
 };
 
@@ -357,8 +322,7 @@ namespace yaml {
 template <> struct MappingTraits<MachineJumpTable> {
   static void mapping(IO &YamlIO, MachineJumpTable &JT) {
     YamlIO.mapRequired("kind", JT.Kind);
-    YamlIO.mapOptional("entries", JT.Entries,
-                       std::vector<MachineJumpTable::Entry>());
+    YamlIO.mapOptional("entries", JT.Entries);
   }
 };
 
@@ -387,43 +351,25 @@ struct MachineFrameInfo {
   bool HasMustTailInVarArgFunc = false;
   StringValue SavePoint;
   StringValue RestorePoint;
-  bool operator==(const MachineFrameInfo &Other) const {
-    return IsFrameAddressTaken == Other.IsFrameAddressTaken &&
-           IsReturnAddressTaken == Other.IsReturnAddressTaken &&
-           HasStackMap == Other.HasStackMap &&
-           HasPatchPoint == Other.HasPatchPoint &&
-           StackSize == Other.StackSize &&
-           OffsetAdjustment == Other.OffsetAdjustment &&
-           MaxAlignment == Other.MaxAlignment &&
-           AdjustsStack == Other.AdjustsStack && HasCalls == Other.HasCalls &&
-           StackProtector == Other.StackProtector &&
-           MaxCallFrameSize == Other.MaxCallFrameSize &&
-           HasOpaqueSPAdjustment == Other.HasOpaqueSPAdjustment &&
-           HasVAStart == Other.HasVAStart &&
-           HasMustTailInVarArgFunc == Other.HasMustTailInVarArgFunc &&
-           SavePoint == Other.SavePoint && RestorePoint == Other.RestorePoint;
-  }
 };
 
 template <> struct MappingTraits<MachineFrameInfo> {
   static void mapping(IO &YamlIO, MachineFrameInfo &MFI) {
-    YamlIO.mapOptional("isFrameAddressTaken", MFI.IsFrameAddressTaken, false);
-    YamlIO.mapOptional("isReturnAddressTaken", MFI.IsReturnAddressTaken, false);
-    YamlIO.mapOptional("hasStackMap", MFI.HasStackMap, false);
-    YamlIO.mapOptional("hasPatchPoint", MFI.HasPatchPoint, false);
-    YamlIO.mapOptional("stackSize", MFI.StackSize, 0ULL);
-    YamlIO.mapOptional("offsetAdjustment", MFI.OffsetAdjustment, 0);
-    YamlIO.mapOptional("maxAlignment", MFI.MaxAlignment, 0U);
-    YamlIO.mapOptional("adjustsStack", MFI.AdjustsStack, false);
-    YamlIO.mapOptional("hasCalls", MFI.HasCalls, false);
+    YamlIO.mapOptional("isFrameAddressTaken", MFI.IsFrameAddressTaken);
+    YamlIO.mapOptional("isReturnAddressTaken", MFI.IsReturnAddressTaken);
+    YamlIO.mapOptional("hasStackMap", MFI.HasStackMap);
+    YamlIO.mapOptional("hasPatchPoint", MFI.HasPatchPoint);
+    YamlIO.mapOptional("stackSize", MFI.StackSize);
+    YamlIO.mapOptional("offsetAdjustment", MFI.OffsetAdjustment);
+    YamlIO.mapOptional("maxAlignment", MFI.MaxAlignment);
+    YamlIO.mapOptional("adjustsStack", MFI.AdjustsStack);
+    YamlIO.mapOptional("hasCalls", MFI.HasCalls);
     YamlIO.mapOptional("stackProtector", MFI.StackProtector,
                        StringValue()); // Don't print it out when it's empty.
     YamlIO.mapOptional("maxCallFrameSize", MFI.MaxCallFrameSize, ~0u);
-    YamlIO.mapOptional("hasOpaqueSPAdjustment", MFI.HasOpaqueSPAdjustment,
-                       false);
-    YamlIO.mapOptional("hasVAStart", MFI.HasVAStart, false);
-    YamlIO.mapOptional("hasMustTailInVarArgFunc", MFI.HasMustTailInVarArgFunc,
-                       false);
+    YamlIO.mapOptional("hasOpaqueSPAdjustment", MFI.HasOpaqueSPAdjustment);
+    YamlIO.mapOptional("hasVAStart", MFI.HasVAStart);
+    YamlIO.mapOptional("hasMustTailInVarArgFunc", MFI.HasMustTailInVarArgFunc);
     YamlIO.mapOptional("savePoint", MFI.SavePoint,
                        StringValue()); // Don't print it out when it's empty.
     YamlIO.mapOptional("restorePoint", MFI.RestorePoint,
@@ -458,29 +404,23 @@ struct MachineFunction {
 template <> struct MappingTraits<MachineFunction> {
   static void mapping(IO &YamlIO, MachineFunction &MF) {
     YamlIO.mapRequired("name", MF.Name);
-    YamlIO.mapOptional("alignment", MF.Alignment, 0U);
-    YamlIO.mapOptional("exposesReturnsTwice", MF.ExposesReturnsTwice, false);
+    YamlIO.mapOptional("alignment", MF.Alignment);
+    YamlIO.mapOptional("exposesReturnsTwice", MF.ExposesReturnsTwice);
     YamlIO.mapOptional("noVRegs", MF.NoVRegs);
-    YamlIO.mapOptional("legalized", MF.Legalized, false);
-    YamlIO.mapOptional("regBankSelected", MF.RegBankSelected, false);
-    YamlIO.mapOptional("selected", MF.Selected, false);
-    YamlIO.mapOptional("tracksRegLiveness", MF.TracksRegLiveness, false);
-    YamlIO.mapOptional("registers", MF.VirtualRegisters,
-                       std::vector<VirtualRegisterDefinition>());
-    YamlIO.mapOptional("liveins", MF.LiveIns,
-                       std::vector<MachineFunctionLiveIn>());
-    YamlIO.mapOptional("calleeSavedRegisters", MF.CalleeSavedRegisters,
-                       Optional<std::vector<FlowStringValue>>());
-    YamlIO.mapOptional("frameInfo", MF.FrameInfo, MachineFrameInfo());
-    YamlIO.mapOptional("fixedStack", MF.FixedStackObjects,
-                       std::vector<FixedMachineStackObject>());
-    YamlIO.mapOptional("stack", MF.StackObjects,
-                       std::vector<MachineStackObject>());
-    YamlIO.mapOptional("constants", MF.Constants,
-                       std::vector<MachineConstantPoolValue>());
+    YamlIO.mapOptional("legalized", MF.Legalized);
+    YamlIO.mapOptional("regBankSelected", MF.RegBankSelected);
+    YamlIO.mapOptional("selected", MF.Selected);
+    YamlIO.mapOptional("tracksRegLiveness", MF.TracksRegLiveness);
+    YamlIO.mapOptional("registers", MF.VirtualRegisters);
+    YamlIO.mapOptional("liveins", MF.LiveIns);
+    YamlIO.mapOptional("calleeSavedRegisters", MF.CalleeSavedRegisters);
+    YamlIO.mapOptional("frameInfo", MF.FrameInfo);
+    YamlIO.mapOptional("fixedStack", MF.FixedStackObjects);
+    YamlIO.mapOptional("stack", MF.StackObjects);
+    YamlIO.mapOptional("constants", MF.Constants);
     if (!YamlIO.outputting() || !MF.JumpTableInfo.Entries.empty())
-      YamlIO.mapOptional("jumpTable", MF.JumpTableInfo, MachineJumpTable());
-    YamlIO.mapOptional("body", MF.Body, BlockStringValue());
+      YamlIO.mapOptional("jumpTable", MF.JumpTableInfo);
+    YamlIO.mapOptional("body", MF.Body);
   }
 };
 

Modified: llvm/trunk/lib/CodeGen/MIRPrinter.cpp
URL: http://llvm.org/viewvc/llvm-project/llvm/trunk/lib/CodeGen/MIRPrinter.cpp?rev=302985&r1=302984&r2=302985&view=diff
==============================================================================
--- llvm/trunk/lib/CodeGen/MIRPrinter.cpp (original)
+++ llvm/trunk/lib/CodeGen/MIRPrinter.cpp Sat May 13 05:59:05 2017
@@ -212,8 +212,6 @@ void MIRPrinter::print(const MachineFunc
   }
   StrOS.flush();
   yaml::Output Out(OS);
-  if (!SimplifyMIR)
-      Out.setWriteDefaultValues(true);
   Out << YamlMF;
 }
 




More information about the llvm-commits mailing list