Run clang-format before making changes to StackMaps. NFC.

git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@241754 91177308-0d34-0410-b5e6-96231b3b80d8

include/llvm/CodeGen/StackMaps.h

@@ -1,5 +1,4 @@
 //===------------------- StackMaps.h - StackMaps ----------------*- C++ -*-===//
-
 //
 //                     The LLVM Compiler Infrastructure
 //
@@ -42,10 +41,12 @@ class PatchPointOpers {
 public:
   /// Enumerate the meta operands.
   enum { IDPos, NBytesPos, TargetPos, NArgPos, CCPos, MetaEnd };
+
 private:
   const MachineInstr *MI;
   bool HasDef;
   bool IsAnyReg;
+
 public:
   explicit PatchPointOpers(const MachineInstr *MI);
 
@@ -66,8 +67,8 @@ public:
   /// Get the operand index of the variable list of non-argument operands.
   /// These hold the "live state".
   unsigned getVarIdx() const {
-    return getMetaIdx() + MetaEnd
+    return getMetaIdx() + MetaEnd +
-      + MI->getOperand(getMetaIdx(NArgPos)).getImm();
+           MI->getOperand(getMetaIdx(NArgPos)).getImm();
   }
 
   /// Get the index at which stack map locations will be recorded.
@@ -98,15 +99,10 @@ private:
 
   // These values are relative offests from the start of the statepoint meta
   // arguments (i.e. the end of the call arguments).
-  enum {
+  enum { CCOffset = 1, FlagsOffset = 3, NumVMSArgsOffset = 5 };
-    CCOffset = 1,
-    FlagsOffset = 3,
-    NumVMSArgsOffset = 5
-  };
 
 public:
-  explicit StatepointOpers(const MachineInstr *MI):
+  explicit StatepointOpers(const MachineInstr *MI) : MI(MI) {}
-    MI(MI) { }
 
   /// Get starting index of non call related arguments
   /// (calling convention, statepoint flags, vm state and gc state).
@@ -134,8 +130,14 @@ private:
 class StackMaps {
 public:
   struct Location {
-    enum LocationType { Unprocessed, Register, Direct, Indirect, Constant,
+    enum LocationType {
-                        ConstantIndex };
+      Unprocessed,
+      Register,
+      Direct,
+      Indirect,
+      Constant,
+      ConstantIndex
+    };
     LocationType LocType;
     unsigned Size;
     unsigned Reg;
@@ -218,8 +220,8 @@ private:
 
   MachineInstr::const_mop_iterator
   parseOperand(MachineInstr::const_mop_iterator MOI,
-               MachineInstr::const_mop_iterator MOE,
+               MachineInstr::const_mop_iterator MOE, LocationVec &Locs,
-               LocationVec &Locs, LiveOutVec &LiveOuts) const;
+               LiveOutVec &LiveOuts) const;
 
   /// \brief Create a live-out register record for the given register @p Reg.
   LiveOutReg createLiveOutReg(unsigned Reg,
@@ -254,7 +256,6 @@ private:
   void print(raw_ostream &OS);
   void debug() { print(dbgs()); }
 };
-
 }
 
 #endif

lib/CodeGen/StackMaps.cpp

@@ -29,17 +29,17 @@ using namespace llvm;
 
 #define DEBUG_TYPE "stackmaps"
 
-static cl::opt<int> StackMapVersion("stackmap-version", cl::init(1),
+static cl::opt<int> StackMapVersion(
+    "stackmap-version", cl::init(1),
     cl::desc("Specify the stackmap encoding version (default = 1)"));
 
 const char *StackMaps::WSMP = "Stack Maps: ";
 
 PatchPointOpers::PatchPointOpers(const MachineInstr *MI)
-  : MI(MI),
+    : MI(MI), HasDef(MI->getOperand(0).isReg() && MI->getOperand(0).isDef() &&
-    HasDef(MI->getOperand(0).isReg() && MI->getOperand(0).isDef() &&
                      !MI->getOperand(0).isImplicit()),
-    IsAnyReg(MI->getOperand(getMetaIdx(CCPos)).getImm() == CallingConv::AnyReg)
+      IsAnyReg(MI->getOperand(getMetaIdx(CCPos)).getImm() ==
-{
+               CallingConv::AnyReg) {
 #ifndef NDEBUG
   unsigned CheckStartIdx = 0, e = MI->getNumOperands();
   while (CheckStartIdx < e && MI->getOperand(CheckStartIdx).isReg() &&
@@ -86,12 +86,13 @@ static unsigned getDwarfRegNum(unsigned Reg, const TargetRegisterInfo *TRI) {
 
 MachineInstr::const_mop_iterator
 StackMaps::parseOperand(MachineInstr::const_mop_iterator MOI,
-                        MachineInstr::const_mop_iterator MOE,
+                        MachineInstr::const_mop_iterator MOE, LocationVec &Locs,
-                        LocationVec &Locs, LiveOutVec &LiveOuts) const {
+                        LiveOutVec &LiveOuts) const {
   const TargetRegisterInfo *TRI = AP.MF->getSubtarget().getRegisterInfo();
   if (MOI->isImm()) {
     switch (MOI->getImm()) {
-    default: llvm_unreachable("Unrecognized operand type.");
+    default:
+      llvm_unreachable("Unrecognized operand type.");
     case StackMaps::DirectMemRefOp: {
       unsigned Size = AP.TM.getDataLayout()->getPointerSizeInBits();
       assert((Size % 8) == 0 && "Need pointer size in bytes.");
@@ -143,8 +144,7 @@ StackMaps::parseOperand(MachineInstr::const_mop_iterator MOI,
     if (SubRegIdx)
       Offset = TRI->getSubRegIdxOffset(SubRegIdx);
 
-    Locs.push_back(
+    Locs.push_back(Location(Location::Register, RC->getSize(), RegNo, Offset));
-      Location(Location::Register, RC->getSize(), RegNo, Offset));
     return ++MOI;
   }
 
@@ -249,8 +249,8 @@ StackMaps::parseRegisterLiveOutMask(const uint32_t *Mask) const {
   // in the list. Merge entries that refer to the same dwarf register and use
   // the maximum size that needs to be spilled.
   std::sort(LiveOuts.begin(), LiveOuts.end());
-  for (LiveOutVec::iterator I = LiveOuts.begin(), E = LiveOuts.end();
+  for (LiveOutVec::iterator I = LiveOuts.begin(), E = LiveOuts.end(); I != E;
-       I != E; ++I) {
+       ++I) {
     for (LiveOutVec::iterator II = std::next(I); II != E; ++II) {
       if (I->RegNo != II->RegNo) {
         // Skip all the now invalid entries.
@@ -263,8 +263,9 @@ StackMaps::parseRegisterLiveOutMask(const uint32_t *Mask) const {
       II->MarkInvalid();
     }
   }
-  LiveOuts.erase(std::remove_if(LiveOuts.begin(), LiveOuts.end(),
+  LiveOuts.erase(
-                                LiveOutReg::IsInvalid), LiveOuts.end());
+      std::remove_if(LiveOuts.begin(), LiveOuts.end(), LiveOutReg::IsInvalid),
+      LiveOuts.end());
   return LiveOuts;
 }
 
@@ -282,8 +283,8 @@ void StackMaps::recordStackMapOpers(const MachineInstr &MI, uint64_t ID,
 
   if (recordResult) {
     assert(PatchPointOpers(&MI).hasDef() && "Stackmap has no return value.");
-    parseOperand(MI.operands_begin(), std::next(MI.operands_begin()),
+    parseOperand(MI.operands_begin(), std::next(MI.operands_begin()), Locations,
-                 Locations, LiveOuts);
+                 LiveOuts);
   }
 
   // Parse operands.
@@ -292,8 +293,8 @@ void StackMaps::recordStackMapOpers(const MachineInstr &MI, uint64_t ID,
   }
 
   // Move large constants into the constant pool.
-  for (LocationVec::iterator I = Locations.begin(), E = Locations.end();
+  for (LocationVec::iterator I = Locations.begin(), E = Locations.end(); I != E;
-       I != E; ++I) {
+       ++I) {
     // Constants are encoded as sign-extended integers.
     // -1 is directly encoded as .long 0xFFFFFFFF with no constant pool.
     if (I->LocType == Location::Constant && !isInt<32>(I->Offset)) {
@@ -317,8 +318,7 @@ void StackMaps::recordStackMapOpers(const MachineInstr &MI, uint64_t ID,
   // entry.
   const MCExpr *CSOffsetExpr = MCBinaryExpr::createSub(
       MCSymbolRefExpr::create(MILabel, OutContext),
-    MCSymbolRefExpr::create(AP.CurrentFnSymForSize, OutContext),
+      MCSymbolRefExpr::create(AP.CurrentFnSymForSize, OutContext), OutContext);
-    OutContext);
 
   CSInfos.emplace_back(CSOffsetExpr, ID, std::move(Locations),
                        std::move(LiveOuts));
@@ -326,8 +326,8 @@ void StackMaps::recordStackMapOpers(const MachineInstr &MI, uint64_t ID,
   // Record the stack size of the current function.
   const MachineFrameInfo *MFI = AP.MF->getFrameInfo();
   const TargetRegisterInfo *RegInfo = AP.MF->getSubtarget().getRegisterInfo();
-  const bool DynamicFrameSize = MFI->hasVarSizedObjects() ||
+  const bool DynamicFrameSize =
-    RegInfo->needsStackRealignment(*(AP.MF));
+      MFI->hasVarSizedObjects() || RegInfo->needsStackRealignment(*(AP.MF));
   FnStackSize[AP.CurrentFnSym] =
       DynamicFrameSize ? UINT64_MAX : MFI->getStackSize();
 }
@@ -363,8 +363,7 @@ void StackMaps::recordPatchPoint(const MachineInstr &MI) {
 #endif
 }
 void StackMaps::recordStatepoint(const MachineInstr &MI) {
-  assert(MI.getOpcode() == TargetOpcode::STATEPOINT &&
+  assert(MI.getOpcode() == TargetOpcode::STATEPOINT && "expected statepoint");
-         "expected statepoint");
 
   StatepointOpers opers(&MI);
   // Record all the deopt and gc operands (they're contiguous and run from the