[Stackmap] Added callsite counts to emitted function information.

[kavon]

Summary

It was previously not possible for tools to use solely the stackmap information emitted to reconstruct the return addresses of callsites in the map, which is necessary to use the information to walk a stack. This patch adds per-function callsite counts when emitting the stackmap section in order to resolve the problem. Note that this slightly alters the stackmap format, so external tools parsing these maps will need to be updated.

Problem Details:
Records only store their offset from the beginning of the function they belong to. While these records and the functions are output in program order, it is not possible to determine where the end of one function's records are without the callsite count when processing the records to compute return addresses.

[sanjoy]

I have not reviewed the code yet, but this looks like the kind of thing that would involve bumping the stackmap version from 1 to 2.

Also CC'ing some other people who might be interested in this.

[kavon]

I updated the original patch so that the record counts are 8 bytes wide instead of 4 bytes wide to fix an alignment issue in the StackMapParser.

The reason this is necessary is that the StackMapParser rounds up the size of every record so that it is divisible by 8 as a means of finding the next 8-byte aligned record, but this method only works if the first record started out 8 byte aligned, which was not guaranteed when I chose to use 4 byte record counts.

[kavon]

this looks like the kind of thing that would involve bumping the stackmap version from 1 to 2.

@sanjoy and others: if this is decided, then the patch will have to change quite a lot, so please let me know!

I made this patch based on the line in the documentation that says "the stack map format is a contract between an LLVM SVN revision and the runtime." Thus, I didn't think it was worth creating a new version when this is a fix for an oversight of a currently experimental intrinsic.

[ributzka]

What about reviving the patch in https://reviews.llvm.org/D13110. Wouldn't that solve your problem too?

[sanjoy]

Looks straightforward. I only have a couple of minor inline comments.

include/llvm/CodeGen/StackMaps.h

196 ↗

(On Diff #68820)

Can you please use a struct here -- it is just too easy to mess up second and first otherwise.

lib/CodeGen/StackMaps.cpp

342 ↗

(On Diff #68820)

Indent looks off? Use clang-format.

534 ↗

(On Diff #68820)

Perhaps call FnInfo FnInfos instead (to go with CSInfos)?

[sanjoy]

In D23487#522272, @ributzka wrote:

What about reviving the patch in https://reviews.llvm.org/D13110. Wouldn't that solve your problem too?

I will let @kavon make the final call on this, but reviving D13110 looks excessively invasive compared to the problem @kavon has.

[ributzka]

If we have to rev the version, which we have to in this case, then I would prefer to have the useful fixes from D13110 in there too. Otherwise this change just feels like a hack on the existing format without addressing any of the other issues.

[kavon]

Updated per sanjoy's inline feedback.

[sanjoy]

Hi @kavon,

In D23487#521887, @kavon wrote:

this looks like the kind of thing that would involve bumping the stackmap version from 1 to 2.

@sanjoy and others: if this is decided, then the patch will have to change quite a lot, so please let me know!

Sorry, I forgot about this bit in the last review. I think the version number needs to change. While I agree that this can be seen as "bugfix" kind of change, in practice changing the format without a version bump will silently break backends.

[kavon]

@ributzka The bug that is fixed by this patch helps all users of stackmaps (gc.statepoint and patchpoints), because you couldn't associate callsites with their functions. I think we should at least merge this fix in so that the current stackmap format is actually usable.

D13110 goes a lot further in that it adds new features for patchpoints, which is not something I'm using right now (I'm using gc.statepoints), so I don't think I'm the right person to revive such an old patch.

[kavon]

In D23487#522475, @sanjoy wrote:

Hi @kavon,

In D23487#521887, @kavon wrote:

this looks like the kind of thing that would involve bumping the stackmap version from 1 to 2.

@sanjoy and others: if this is decided, then the patch will have to change quite a lot, so please let me know!

Sorry, I forgot about this bit in the last review. I think the version number needs to change. While I agree that this can be seen as "bugfix" kind of change, in practice changing the format without a version bump will silently break backends.

Should we also maintain backwards compatibility with version 1 map generation & parsing, or should I just change it to version number 2 to let others know they need to tweak their code? (I'm in favor the latter).

[sanjoy]

Hi @kavon,

In D23487#522498, @kavon wrote:

Should we also maintain backwards compatibility with version 1 map
generation & parsing, or should I just change it to version number 2
to let others know they need to tweak their code? (I'm in favor the
latter).

I'm in favor of the latter too (though I'm interested in what
@ributzka thinks). I'd suggest sending a mail to llvm-dev stating
that you're bumping the stackmap version in a backward incompatible
manner and see if anyone objects.

FWIW, I don't think this should be a problem for us.

include/llvm/CodeGen/StackMaps.h

198 ↗

(On Diff #68899)

Why do you need this default constructor?

199 ↗

(On Diff #68899)

Make the constructor explicit.

lib/CodeGen/StackMaps.cpp

342 ↗

(On Diff #68899)

s/current/Current/ in keeping with LLVM coding style.

343 ↗

(On Diff #68899)

Why do you need to assign StackSize again?

Can't this whole block be:

auto CurrentIt = FnInfos.find(AP.CurrentFnSym);
if (CurrentIt != FnInfos.end()
  CurrentIt->second.RecordCount++;
else
  FnInfos.insert(...);

?

[sanjoy]

Hi @kavon,

In D23487#522498, @kavon wrote:

Should we also maintain backwards compatibility with version 1 map
generation & parsing, or should I just change it to version number 2
to let others know they need to tweak their code? (I'm in favor the
latter).

I'm in favor of the latter too (though I'm interested in what
@ributzka thinks). I'd suggest sending a mail to llvm-dev stating
that you're bumping the stackmap version in a backward incompatible
manner and see if anyone objects.

FWIW, I don't think this should be a problem for us.

[kavon]

(added replies to inline comments ahead of adding a new revision)

include/llvm/CodeGen/StackMaps.h

198 ↗

(On Diff #68899)

The implementation of MapVector requires it. Here's the error if you remove it:

include/llvm/ADT/MapVector.h:80:44: error: 
      no matching constructor for initialization of 'llvm::StackMaps::FunctionInfo'
      Vector.push_back(std::make_pair(Key, ValueT()));
                                           ^

lib/CodeGen/StackMaps.cpp

343 ↗

(On Diff #68899)

I only reassign StackSize because that's what the previous implementation did, and I didn't want to mess with a good thing ;)

I have now changed the block to match your suggestion.

[kavon]

This revision includes the changes requested in the inline comments.

@sanjoy I have sent an email to the llvm-dev list about stackmap versioning:

https://groups.google.com/forum/#!topic/llvm-dev/Ci7yLVw6itw

I will create a another revision that also bumps the version from 1 to 2 after giving people a chance to respond to the email.

[ributzka]

I'm in favor of the latter too (though I'm interested in what
@ributzka thinks). I'd suggest sending a mail to llvm-dev stating
that you're bumping the stackmap version in a backward incompatible
manner and see if anyone objects.

FWIW, I don't think this should be a problem for us.

I don't have a problem with that either.

[kavon]

Okay, here's a version with the stackmap version bumped to 2.

[sanjoy]

lgtm

Do you have commit access? If not let me know here and I'll land this for you.

include/llvm/Object/StackMapParser.h

59 ↗

(On Diff #70947)

Just to be clear: this was wrong to begin with (for functions with stack frames larger than 4 gb :) )?

lib/CodeGen/StackMaps.cpp

345 ↗

(On Diff #70947)

I think this can be FnInfos.insert({AP.CurrentFnSym, FunctionInfo(FrameSize)});

[kavon]

@sanjoy

I don't have commit access, so if you could merge this patch for me that would be great.

One thing to note is that the diff in this Phabricator review doesn't include one of the binary files needed in the regression tests. Specifically, you'll need to generate test/Object/Inputs/stackmap-test.macho-x86-64 after the patch is applied (see the comment at the top of test/Object/stackmap-dump.test)

include/llvm/Object/StackMapParser.h

59 ↗

(On Diff #70947)

Yes, this was an existing issue I noticed and fixed, since the field is 64 bits.

llvm/trunk/docs/StackMaps.rst

 
 The existence of a stack map or patch point intrinsic within an LLVM
 Module forces code emission to create a :ref:`stackmap-section`. The
 format of this section follows:
 
 .. code-block:: none
 
   Header {
-    uint8  : Stack Map Version (current version is 1)
+    uint8  : Stack Map Version (current version is 2)
     uint8  : Reserved (expected to be 0)
     uint16 : Reserved (expected to be 0)
   }
   uint32 : NumFunctions
   uint32 : NumConstants
   uint32 : NumRecords
   StkSizeRecord[NumFunctions] {
     uint64 : Function Address
     uint64 : Stack Size
+    uint64 : Record Count
   }
   Constants[NumConstants] {
     uint64 : LargeConstant
   }
   StkMapRecord[NumRecords] {
     uint64 : PatchPoint ID
     uint32 : Instruction Offset
     uint16 : Reserved (record flags)

 Stack Map Usage
 ===============
 
 The stack map support described in this document can be used to
 precisely determine the location of values at a specific position in
 the code. LLVM does not maintain any mapping between those values and
 any higher-level entity. The runtime must be able to interpret the
 stack map record given only the ID, offset, and the order of the
-locations, which LLVM preserves.
+locations, records, and functions, which LLVM preserves.
 
 Note that this is quite different from the goal of debug information,
 which is a best-effort attempt to track the location of named
 variables at every instruction.
 
 An important motivation for this design is to allow a runtime to
 commandeer a stack frame when execution reaches an instruction address
 associated with a stack map. The runtime must be able to rebuild a

 
 Supported Architectures
 =======================
 
 Support for StackMap generation and the related intrinsics requires 
 some code for each backend.  Today, only a subset of LLVM's backends 
 are supported.  The currently supported architectures are X86_64, 
 PowerPC, and Aarch64.
-

llvm/trunk/include/llvm/CodeGen/StackMaps.h

public:
   // OpParser.
   typedef enum { DirectMemRefOp, IndirectMemRefOp, ConstantOp } OpType;
 
   StackMaps(AsmPrinter &AP);
 
   void reset() {
     CSInfos.clear();
     ConstPool.clear();
-    FnStackSize.clear();
+    FnInfos.clear();
   }
 
   /// \brief Generate a stackmap record for a stackmap instruction.
   ///
   /// MI must be a raw STACKMAP, not a PATCHPOINT.
   void recordStackMap(const MachineInstr &MI);
 
   /// \brief Generate a stackmap record for a patchpoint instruction.
   void recordPatchPoint(const MachineInstr &MI);
 
   /// \brief Generate a stackmap record for a statepoint instruction.
   void recordStatepoint(const MachineInstr &MI);
 
   /// If there is any stack map data, create a stack map section and serialize
   /// the map info into it. This clears the stack map data structures
   /// afterwards.
   void serializeToStackMapSection();
 
 private:
   static const char *WSMP;
   typedef SmallVector<Location, 8> LocationVec;
   typedef SmallVector<LiveOutReg, 8> LiveOutVec;
   typedef MapVector<uint64_t, uint64_t> ConstantPool;
-  typedef MapVector<const MCSymbol *, uint64_t> FnStackSizeMap;
+
+  struct FunctionInfo {
+    uint64_t StackSize;
+    uint64_t RecordCount;
+    FunctionInfo() : StackSize(0), RecordCount(1) {}
+    explicit FunctionInfo(uint64_t StackSize) : StackSize(StackSize), RecordCount(1) {}
+  };
 
   struct CallsiteInfo {
     const MCExpr *CSOffsetExpr;
     uint64_t ID;
     LocationVec Locations;
     LiveOutVec LiveOuts;
     CallsiteInfo() : CSOffsetExpr(nullptr), ID(0) {}
     CallsiteInfo(const MCExpr *CSOffsetExpr, uint64_t ID,
                  LocationVec &&Locations, LiveOutVec &&LiveOuts)
         : CSOffsetExpr(CSOffsetExpr), ID(ID), Locations(std::move(Locations)),
           LiveOuts(std::move(LiveOuts)) {}
   };
 
+  typedef MapVector<const MCSymbol *, FunctionInfo> FnInfoMap;
   typedef std::vector<CallsiteInfo> CallsiteInfoList;
 
   AsmPrinter &AP;
   CallsiteInfoList CSInfos;
   ConstantPool ConstPool;
-  FnStackSizeMap FnStackSize;
+  FnInfoMap FnInfos;
 
   MachineInstr::const_mop_iterator
   parseOperand(MachineInstr::const_mop_iterator MOI,
                MachineInstr::const_mop_iterator MOE, LocationVec &Locs,
                LiveOutVec &LiveOuts) const;
 
   /// \brief Create a live-out register record for the given register @p Reg.
   LiveOutReg createLiveOutReg(unsigned Reg,

llvm/trunk/include/llvm/Object/StackMapParser.h

 
 #include "llvm/ADT/ArrayRef.h"
 #include "llvm/Support/Endian.h"
 #include <vector>
 
 namespace llvm {
 
 template <support::endianness Endianness>
-class StackMapV1Parser {
+class StackMapV2Parser {
 public:
 
   template <typename AccessorT>
   class AccessorIterator {
   public:
 
     AccessorIterator(AccessorT A) : A(A) {}
     AccessorIterator& operator++() { A = A.next(); return *this; }
public:
     AccessorT* operator->() { return &A; }
 
   private:
     AccessorT A;
   };
 
   /// Accessor for function records.
   class FunctionAccessor {
-    friend class StackMapV1Parser;
+    friend class StackMapV2Parser;
   public:
 
     /// Get the function address.
     uint64_t getFunctionAddress() const {
       return read<uint64_t>(P);
     }
 
     /// Get the function's stack size.
-    uint32_t getStackSize() const {
+    uint64_t getStackSize() const {
       return read<uint64_t>(P + sizeof(uint64_t));
     }
     
+    /// Get the number of callsite records.
+    uint64_t getRecordCount() const {
+      return read<uint64_t>(P + (2 * sizeof(uint64_t)));
+    }
+
   private:
     FunctionAccessor(const uint8_t *P) : P(P) {}
 
-    const static int FunctionAccessorSize = 2 * sizeof(uint64_t);
+    const static int FunctionAccessorSize = 3 * sizeof(uint64_t);
 
     FunctionAccessor next() const {
       return FunctionAccessor(P + FunctionAccessorSize);
     }
 
     const uint8_t *P;
   };
 
   /// Accessor for constants.
   class ConstantAccessor {
-    friend class StackMapV1Parser;
+    friend class StackMapV2Parser;
   public:
 
     /// Return the value of this constant.
     uint64_t getValue() const { return read<uint64_t>(P); }
 
   private:
 
     ConstantAccessor(const uint8_t *P) : P(P) {}
public:
 
   enum class LocationKind : uint8_t {
     Register = 1, Direct = 2, Indirect = 3, Constant = 4, ConstantIndex = 5
   };
 
 
   /// Accessor for location records.
   class LocationAccessor {
-    friend class StackMapV1Parser;
+    friend class StackMapV2Parser;
     friend class RecordAccessor;
   public:
 
     /// Get the Kind for this location.
     LocationKind getKind() const {
       return LocationKind(P[KindOffset]);
     }
 
private:
     static const int SmallConstantOffset = DwarfRegNumOffset + sizeof(uint16_t);
     static const int LocationAccessorSize = sizeof(uint64_t);
 
     const uint8_t *P;
   };
 
   /// Accessor for stackmap live-out fields.
   class LiveOutAccessor {
-    friend class StackMapV1Parser;
+    friend class StackMapV2Parser;
     friend class RecordAccessor;
   public:
 
     /// Get the Dwarf register number for this live-out.
     uint16_t getDwarfRegNum() const {
       return read<uint16_t>(P + DwarfRegNumOffset);
     }
 
static const int SizeOffset =
       DwarfRegNumOffset + sizeof(uint16_t) + sizeof(uint8_t);
     static const int LiveOutAccessorSize = sizeof(uint32_t);
 
     const uint8_t *P;
   };
 
   /// Accessor for stackmap records.
   class RecordAccessor {
-    friend class StackMapV1Parser;
+    friend class StackMapV2Parser;
   public:
 
     typedef AccessorIterator<LocationAccessor> location_iterator;
     typedef AccessorIterator<LiveOutAccessor> liveout_iterator;
 
     /// Get the patchpoint/stackmap ID for this record.
     uint64_t getID() const {
       return read<uint64_t>(P + PatchpointIDOffset);
private:
     static const unsigned LocationListOffset =
       NumLocationsOffset + sizeof(uint16_t);
     static const unsigned LocationSize = sizeof(uint64_t);
     static const unsigned LiveOutSize = sizeof(uint32_t);
 
     const uint8_t *P;
   };
 
-  /// Construct a parser for a version-1 stackmap. StackMap data will be read
+  /// Construct a parser for a version-2 stackmap. StackMap data will be read
   /// from the given array.
-  StackMapV1Parser(ArrayRef<uint8_t> StackMapSection)
+  StackMapV2Parser(ArrayRef<uint8_t> StackMapSection)
       : StackMapSection(StackMapSection) {
     ConstantsListOffset = FunctionListOffset + getNumFunctions() * FunctionSize;
 
-    assert(StackMapSection[0] == 1 &&
-           "StackMapV1Parser can only parse version 1 stackmaps");
+    assert(StackMapSection[0] == 2 &&
+           "StackMapV2Parser can only parse version 2 stackmaps");
 
     unsigned CurrentRecordOffset =
       ConstantsListOffset + getNumConstants() * ConstantSize;
 
     for (unsigned I = 0, E = getNumRecords(); I != E; ++I) {
       StackMapRecordOffsets.push_back(CurrentRecordOffset);
       CurrentRecordOffset +=
         RecordAccessor(&StackMapSection[CurrentRecordOffset]).getSizeInBytes();
     }
   }
 
   typedef AccessorIterator<FunctionAccessor> function_iterator;
   typedef AccessorIterator<ConstantAccessor> constant_iterator;
   typedef AccessorIterator<RecordAccessor> record_iterator;
 
-  /// Get the version number of this stackmap. (Always returns 1).
-  unsigned getVersion() const { return 1; }
+  /// Get the version number of this stackmap. (Always returns 2).
+  unsigned getVersion() const { return 2; }
 
   /// Get the number of functions in the stack map.
   uint32_t getNumFunctions() const {
     return read<uint32_t>(&StackMapSection[NumFunctionsOffset]);
   }
 
   /// Get the number of large constants in the stack map.
   uint32_t getNumConstants() const {
private:
   }
 
   static const unsigned HeaderOffset = 0;
   static const unsigned NumFunctionsOffset = HeaderOffset + sizeof(uint32_t);
   static const unsigned NumConstantsOffset = NumFunctionsOffset + sizeof(uint32_t);
   static const unsigned NumRecordsOffset = NumConstantsOffset + sizeof(uint32_t);
   static const unsigned FunctionListOffset = NumRecordsOffset + sizeof(uint32_t);
 
-  static const unsigned FunctionSize = 2 * sizeof(uint64_t);
+  static const unsigned FunctionSize = 3 * sizeof(uint64_t);
   static const unsigned ConstantSize = sizeof(uint64_t);
 
   std::size_t getFunctionOffset(unsigned FunctionIndex) const {
     return FunctionListOffset + FunctionIndex * FunctionSize;
   }
 
   std::size_t getConstantOffset(unsigned ConstantIndex) const {
     return ConstantsListOffset + ConstantIndex * ConstantSize;

llvm/trunk/lib/CodeGen/StackMaps.cpp

 #include "llvm/Target/TargetSubtargetInfo.h"
 #include <iterator>
 
 using namespace llvm;
 
 #define DEBUG_TYPE "stackmaps"
 
 static cl::opt<int> StackMapVersion(
-    "stackmap-version", cl::init(1),
-    cl::desc("Specify the stackmap encoding version (default = 1)"));
+    "stackmap-version", cl::init(2),
+    cl::desc("Specify the stackmap encoding version (default = 2)"));
 
 const char *StackMaps::WSMP = "Stack Maps: ";
 
 StackMapOpers::StackMapOpers(const MachineInstr *MI)
   : MI(MI) {
   assert(getVarIdx() <= MI->getNumOperands() &&
          "invalid stackmap definition");
 }
while (ScratchIdx < e &&
            MI->getOperand(ScratchIdx).isEarlyClobber()))
     ++ScratchIdx;
 
   assert(ScratchIdx != e && "No scratch register available");
   return ScratchIdx;
 }
 
 StackMaps::StackMaps(AsmPrinter &AP) : AP(AP) {
-  if (StackMapVersion != 1)
+  if (StackMapVersion != 2)
     llvm_unreachable("Unsupported stackmap version!");
 }
 
 /// Go up the super-register chain until we hit a valid dwarf register number.
 static unsigned getDwarfRegNum(unsigned Reg, const TargetRegisterInfo *TRI) {
   int RegNum = TRI->getDwarfRegNum(Reg, false);
   for (MCSuperRegIterator SR(Reg, TRI); SR.isValid() && RegNum < 0; ++SR)
     RegNum = TRI->getDwarfRegNum(*SR, false);
void StackMaps::recordStackMapOpers(const MachineInstr &MI, uint64_t ID,
   // entry.
   const MCExpr *CSOffsetExpr = MCBinaryExpr::createSub(
       MCSymbolRefExpr::create(MILabel, OutContext),
       MCSymbolRefExpr::create(AP.CurrentFnSymForSize, OutContext), OutContext);
 
   CSInfos.emplace_back(CSOffsetExpr, ID, std::move(Locations),
                        std::move(LiveOuts));
 
-  // Record the stack size of the current function.
+  // Record the stack size of the current function and update callsite count.
   const MachineFrameInfo &MFI = AP.MF->getFrameInfo();
   const TargetRegisterInfo *RegInfo = AP.MF->getSubtarget().getRegisterInfo();
   bool HasDynamicFrameSize =
       MFI.hasVarSizedObjects() || RegInfo->needsStackRealignment(*(AP.MF));
-  FnStackSize[AP.CurrentFnSym] =
-      HasDynamicFrameSize ? UINT64_MAX : MFI.getStackSize();
+  uint64_t FrameSize = HasDynamicFrameSize ? UINT64_MAX : MFI.getStackSize();
+
+  auto CurrentIt = FnInfos.find(AP.CurrentFnSym);
+  if (CurrentIt != FnInfos.end())
+    CurrentIt->second.RecordCount++;
+  else
+    FnInfos.insert(std::make_pair(AP.CurrentFnSym, FunctionInfo(FrameSize)));
 }
 
 void StackMaps::recordStackMap(const MachineInstr &MI) {
   assert(MI.getOpcode() == TargetOpcode::STACKMAP && "expected stackmap");
 
   StackMapOpers opers(&MI);
   const int64_t ID = MI.getOperand(PatchPointOpers::IDPos).getImm();
   recordStackMapOpers(MI, ID, std::next(MI.operands_begin(), opers.getVarIdx()),
void StackMaps::recordStatepoint(const MachineInstr &MI) {
   const unsigned StartIdx = opers.getVarIdx();
   recordStackMapOpers(MI, opers.getID(), MI.operands_begin() + StartIdx,
                       MI.operands_end(), false);
 }
 
 /// Emit the stackmap header.
 ///
 /// Header {
-///   uint8  : Stack Map Version (currently 1)
+///   uint8  : Stack Map Version (currently 2)
 ///   uint8  : Reserved (expected to be 0)
 ///   uint16 : Reserved (expected to be 0)
 /// }
 /// uint32 : NumFunctions
 /// uint32 : NumConstants
 /// uint32 : NumRecords
 void StackMaps::emitStackmapHeader(MCStreamer &OS) {
   // Header.
   OS.EmitIntValue(StackMapVersion, 1); // Version.
   OS.EmitIntValue(0, 1);               // Reserved.
   OS.EmitIntValue(0, 2);               // Reserved.
 
   // Num functions.
-  DEBUG(dbgs() << WSMP << "#functions = " << FnStackSize.size() << '\n');
-  OS.EmitIntValue(FnStackSize.size(), 4);
+  DEBUG(dbgs() << WSMP << "#functions = " << FnInfos.size() << '\n');
+  OS.EmitIntValue(FnInfos.size(), 4);
   // Num constants.
   DEBUG(dbgs() << WSMP << "#constants = " << ConstPool.size() << '\n');
   OS.EmitIntValue(ConstPool.size(), 4);
   // Num callsites.
   DEBUG(dbgs() << WSMP << "#callsites = " << CSInfos.size() << '\n');
   OS.EmitIntValue(CSInfos.size(), 4);
 }
 
 /// Emit the function frame record for each function.
 ///
 /// StkSizeRecord[NumFunctions] {
 ///   uint64 : Function Address
 ///   uint64 : Stack Size
+///   uint64 : Record Count
 /// }
 void StackMaps::emitFunctionFrameRecords(MCStreamer &OS) {
   // Function Frame records.
   DEBUG(dbgs() << WSMP << "functions:\n");
-  for (auto const &FR : FnStackSize) {
+  for (auto const &FR : FnInfos) {
     DEBUG(dbgs() << WSMP << "function addr: " << FR.first
-                 << " frame size: " << FR.second);
+                 << " frame size: " << FR.second.StackSize
+                 << " callsite count: " << FR.second.RecordCount << '\n');
     OS.EmitSymbolValue(FR.first, 8);
-    OS.EmitIntValue(FR.second, 8);
+    OS.EmitIntValue(FR.second.StackSize, 8);
+    OS.EmitIntValue(FR.second.RecordCount, 8);
   }
 }
 
 /// Emit the constant pool.
 ///
 /// int64  : Constants[NumConstants]
 void StackMaps::emitConstantPoolEntries(MCStreamer &OS) {
   // Constant pool entries.

 }
 
 /// Serialize the stackmap data.
 void StackMaps::serializeToStackMapSection() {
   (void)WSMP;
   // Bail out if there's no stack map data.
   assert((!CSInfos.empty() || ConstPool.empty()) &&
          "Expected empty constant pool too!");
-  assert((!CSInfos.empty() || FnStackSize.empty()) &&
+  assert((!CSInfos.empty() || FnInfos.empty()) &&
          "Expected empty function record too!");
   if (CSInfos.empty())
     return;
 
   MCContext &OutContext = AP.OutStreamer->getContext();
   MCStreamer &OS = *AP.OutStreamer;
 
   // Create the section.

llvm/trunk/test/CodeGen/AArch64/arm64-anyregcc.ll

 ; RUN: llc < %s -mtriple=arm64-apple-darwin | FileCheck %s
 
 ; Stackmap Header: no constants - 6 callsites
 ; CHECK-LABEL: .section __LLVM_STACKMAPS,__llvm_stackmaps
 ; CHECK-NEXT:  __LLVM_StackMaps:
 ; Header
-; CHECK-NEXT:   .byte 1
+; CHECK-NEXT:   .byte 2
 ; CHECK-NEXT:   .byte 0
 ; CHECK-NEXT:   .short 0
 ; Num Functions
 ; CHECK-NEXT:   .long 8
 ; Num LargeConstants
 ; CHECK-NEXT:   .long 0
 ; Num Callsites
 ; CHECK-NEXT:   .long 8
 
 ; Functions and stack size
 ; CHECK-NEXT:   .quad _test
 ; CHECK-NEXT:   .quad 16
+; CHECK-NEXT:   .quad 1
 ; CHECK-NEXT:   .quad _property_access1
 ; CHECK-NEXT:   .quad 16
+; CHECK-NEXT:   .quad 1
 ; CHECK-NEXT:   .quad _property_access2
 ; CHECK-NEXT:   .quad 32
+; CHECK-NEXT:   .quad 1
 ; CHECK-NEXT:   .quad _property_access3
 ; CHECK-NEXT:   .quad 32
+; CHECK-NEXT:   .quad 1
 ; CHECK-NEXT:   .quad _anyreg_test1
 ; CHECK-NEXT:   .quad 16
+; CHECK-NEXT:   .quad 1
 ; CHECK-NEXT:   .quad _anyreg_test2
 ; CHECK-NEXT:   .quad 16
+; CHECK-NEXT:   .quad 1
 ; CHECK-NEXT:   .quad _patchpoint_spilldef
 ; CHECK-NEXT:   .quad 112
+; CHECK-NEXT:   .quad 1
 ; CHECK-NEXT:   .quad _patchpoint_spillargs
 ; CHECK-NEXT:   .quad 128
+; CHECK-NEXT:   .quad 1
 
 
 ; test
 ; CHECK-LABEL:  .long   L{{.*}}-_test
 ; CHECK-NEXT:   .short  0
 ; 3 locations
 ; CHECK-NEXT:   .short  3
 ; Loc 0: Register

llvm/trunk/test/CodeGen/AArch64/arm64-stackmap.ll

 ; RUN: llc -mtriple=arm64-apple-darwin -mattr=+reserve-x18                             < %s | FileCheck %s
 ; RUN: llc -mtriple=arm64-apple-darwin -mattr=+reserve-x18 -fast-isel -fast-isel-abort=1 < %s | FileCheck %s
 ;
 ; Note: Print verbose stackmaps using -debug-only=stackmaps.
 
 ; We are not getting the correct stack alignment when cross compiling for arm64.
 ; So specify a datalayout here.
 target datalayout = "e-m:o-i64:64-f80:128-n8:16:32:64-S128"
 
 ; CHECK-LABEL:  .section  __LLVM_STACKMAPS,__llvm_stackmaps
 ; CHECK-NEXT:  __LLVM_StackMaps:
 ; Header
-; CHECK-NEXT:   .byte 1
+; CHECK-NEXT:   .byte 2
 ; CHECK-NEXT:   .byte 0
 ; CHECK-NEXT:   .short 0
 ; Num Functions
 ; CHECK-NEXT:   .long 11
 ; Num LargeConstants
 ; CHECK-NEXT:   .long 2
 ; Num Callsites
 ; CHECK-NEXT:   .long 11
 
 ; Functions and stack size
 ; CHECK-NEXT:   .quad _constantargs
 ; CHECK-NEXT:   .quad 16
+; CHECK-NEXT:   .quad 1
 ; CHECK-NEXT:   .quad _osrinline
 ; CHECK-NEXT:   .quad 32
+; CHECK-NEXT:   .quad 1
 ; CHECK-NEXT:   .quad _osrcold
 ; CHECK-NEXT:   .quad 16
+; CHECK-NEXT:   .quad 1
 ; CHECK-NEXT:   .quad _propertyRead
 ; CHECK-NEXT:   .quad 16
+; CHECK-NEXT:   .quad 1
 ; CHECK-NEXT:   .quad _propertyWrite
 ; CHECK-NEXT:   .quad 16
+; CHECK-NEXT:   .quad 1
 ; CHECK-NEXT:   .quad _jsVoidCall
 ; CHECK-NEXT:   .quad 16
+; CHECK-NEXT:   .quad 1
 ; CHECK-NEXT:   .quad _jsIntCall
 ; CHECK-NEXT:   .quad 16
+; CHECK-NEXT:   .quad 1
 ; CHECK-NEXT:   .quad _spilledValue
 ; CHECK-NEXT:   .quad 160
+; CHECK-NEXT:   .quad 1
 ; CHECK-NEXT:   .quad _spilledStackMapValue
 ; CHECK-NEXT:   .quad 128
+; CHECK-NEXT:   .quad 1
 ; CHECK-NEXT:   .quad _liveConstant
 ; CHECK-NEXT:   .quad 16
+; CHECK-NEXT:   .quad 1
 ; CHECK-NEXT:   .quad _clobberLR
 ; CHECK-NEXT:   .quad 112
+; CHECK-NEXT:   .quad 1
 
 ; Num LargeConstants
 ; CHECK-NEXT:   .quad   4294967295
 ; CHECK-NEXT:   .quad   4294967296
 
 ; Constant arguments
 ;
 ; CHECK-NEXT:   .quad   1

llvm/trunk/test/CodeGen/AArch64/stackmap-liveness.ll

 ; RUN: llc < %s -mtriple=aarch64-apple-darwin | FileCheck %s
 
 target datalayout = "e-m:o-i64:64-i128:128-n32:64-S128"
 
 ; CHECK-LABEL:  .section  __LLVM_STACKMAPS,__llvm_stackmaps
 ; CHECK-NEXT:   __LLVM_StackMaps:
 ; Header
-; CHECK-NEXT:   .byte 1
+; CHECK-NEXT:   .byte 2
 ; CHECK-NEXT:   .byte 0
 ; CHECK-NEXT:   .short 0
 ; Num Functions
 ; CHECK-NEXT:   .long 1
 ; Num LargeConstants
 ; CHECK-NEXT:   .long   0
 ; Num Callsites
 ; CHECK-NEXT:   .long   1

 ; Align
 ; CHECK-NEXT:   .p2align  3
   %1 = select i1 %c, i64 1, i64 2
   call anyregcc void (i64, i32, i8*, i32, ...) @llvm.experimental.patchpoint.void(i64 1, i32 32, i8* null, i32 0)
   ret i64 %1
 }
 
 declare void @llvm.experimental.patchpoint.void(i64, i32, i8*, i32, ...)
-

llvm/trunk/test/CodeGen/PowerPC/ppc64-anyregcc.ll

 ; CHECK-LABEL: patchpoint_spillargs:
 ; CHECK: {{^}}.L[[patchpoint_spillargs_BEGIN:.*]]:{{$}}
 
 
 ; Stackmap Header: no constants - 6 callsites
 ; CHECK-LABEL: .section .llvm_stackmaps
 ; CHECK-NEXT:  __LLVM_StackMaps:
 ; Header
-; CHECK-NEXT:   .byte 1
+; CHECK-NEXT:   .byte 2
 ; CHECK-NEXT:   .byte 0
 ; CHECK-NEXT:   .short 0
 ; Num Functions
 ; CHECK-NEXT:   .long 8
 ; Num LargeConstants
 ; CHECK-NEXT:   .long 0
 ; Num Callsites
 ; CHECK-NEXT:   .long 8
 
 ; Functions and stack size
 ; CHECK-NEXT:   .quad test
 ; CHECK-NEXT:   .quad 128
+; CHECK-NEXT:   .quad 1
 ; CHECK-NEXT:   .quad property_access1
 ; CHECK-NEXT:   .quad 128
+; CHECK-NEXT:   .quad 1
 ; CHECK-NEXT:   .quad property_access2
 ; CHECK-NEXT:   .quad 128
+; CHECK-NEXT:   .quad 1
 ; CHECK-NEXT:   .quad property_access3
 ; CHECK-NEXT:   .quad 128
+; CHECK-NEXT:   .quad 1
 ; CHECK-NEXT:   .quad anyreg_test1
 ; CHECK-NEXT:   .quad 144
+; CHECK-NEXT:   .quad 1
 ; CHECK-NEXT:   .quad anyreg_test2
 ; CHECK-NEXT:   .quad 144
+; CHECK-NEXT:   .quad 1
 ; CHECK-NEXT:   .quad patchpoint_spilldef
 ; CHECK-NEXT:   .quad 256
+; CHECK-NEXT:   .quad 1
 ; CHECK-NEXT:   .quad patchpoint_spillargs
 ; CHECK-NEXT:   .quad 288
+; CHECK-NEXT:   .quad 1
 
 
 ; test
 ; CHECK:  .long   .L{{.*}}-.L[[test_BEGIN]]
 ; CHECK-NEXT:   .short  0
 ; 3 locations
 ; CHECK-NEXT:   .short  3
 ; Loc 0: Register

llvm/trunk/test/CodeGen/PowerPC/ppc64-stackmap.ll

 
 ; CHECK-LABEL: clobberLR:
 ; CHECK: {{^}}.L[[clobberLR_BEGIN:.*]]:{{$}}
 
 
 ; CHECK-LABEL:  .section  .llvm_stackmaps
 ; CHECK-NEXT:  __LLVM_StackMaps:
 ; Header
-; CHECK-NEXT:   .byte 1
+; CHECK-NEXT:   .byte 2
 ; CHECK-NEXT:   .byte 0
 ; CHECK-NEXT:   .short 0
 ; Num Functions
 ; CHECK-NEXT:   .long 11
 ; Num LargeConstants
 ; CHECK-NEXT:   .long 2
 ; Num Callsites
 ; CHECK-NEXT:   .long 11
 
 ; Functions and stack size
 ; CHECK-NEXT:   .quad constantargs
 ; CHECK-NEXT:   .quad 128
+; CHECK-NEXT:   .quad 1
 ; CHECK-NEXT:   .quad osrinline
 ; CHECK-NEXT:   .quad 144
+; CHECK-NEXT:   .quad 1
 ; CHECK-NEXT:   .quad osrcold
 ; CHECK-NEXT:   .quad 128
+; CHECK-NEXT:   .quad 1
 ; CHECK-NEXT:   .quad propertyRead
 ; CHECK-NEXT:   .quad 128
+; CHECK-NEXT:   .quad 1
 ; CHECK-NEXT:   .quad propertyWrite
 ; CHECK-NEXT:   .quad 128
+; CHECK-NEXT:   .quad 1
 ; CHECK-NEXT:   .quad jsVoidCall
 ; CHECK-NEXT:   .quad 128
+; CHECK-NEXT:   .quad 1
 ; CHECK-NEXT:   .quad jsIntCall
 ; CHECK-NEXT:   .quad 128
+; CHECK-NEXT:   .quad 1
 ; CHECK-NEXT:   .quad spilledValue
 ; CHECK-NEXT:   .quad 304
+; CHECK-NEXT:   .quad 1
 ; CHECK-NEXT:   .quad spilledStackMapValue
 ; CHECK-NEXT:   .quad 224
+; CHECK-NEXT:   .quad 1
 ; CHECK-NEXT:   .quad liveConstant
 ; CHECK-NEXT:   .quad 64
+; CHECK-NEXT:   .quad 1
 ; CHECK-NEXT:   .quad clobberLR
 ; CHECK-NEXT:   .quad 208
+; CHECK-NEXT:   .quad 1
 
 ; Num LargeConstants
 ; CHECK-NEXT:   .quad   4294967295
 ; CHECK-NEXT:   .quad   4294967296
 
 ; Constant arguments
 ;
 ; CHECK-NEXT:   .quad   1

llvm/trunk/test/CodeGen/X86/anyregcc.ll

 ; RUN: llc < %s -mtriple=x86_64-apple-darwin                  -disable-fp-elim | FileCheck %s
 ; RUN: llc < %s -mtriple=x86_64-apple-darwin -mcpu=corei7     -disable-fp-elim | FileCheck --check-prefix=SSE %s
 ; RUN: llc < %s -mtriple=x86_64-apple-darwin -mcpu=corei7-avx -disable-fp-elim | FileCheck --check-prefix=AVX %s
 
 
 ; Stackmap Header: no constants - 6 callsites
 ; CHECK-LABEL:  .section __LLVM_STACKMAPS,__llvm_stackmaps
 ; CHECK-NEXT:   __LLVM_StackMaps:
 ; Header
-; CHECK-NEXT:   .byte 1
+; CHECK-NEXT:   .byte 2
 ; CHECK-NEXT:   .byte 0
 ; CHECK-NEXT:   .short 0
 ; Num Functions
 ; CHECK-NEXT:   .long 8
 ; Num Constants
 ; CHECK-NEXT:   .long 0
 ; Num Callsites
 ; CHECK-NEXT:   .long 8
 
 ; Functions and stack size
 ; CHECK-NEXT:   .quad _test
 ; CHECK-NEXT:   .quad 8
+; CHECK-NEXT:   .quad 1
 ; CHECK-NEXT:   .quad _property_access1
 ; CHECK-NEXT:   .quad 8
+; CHECK-NEXT:   .quad 1
 ; CHECK-NEXT:   .quad _property_access2
 ; CHECK-NEXT:   .quad 24
+; CHECK-NEXT:   .quad 1
 ; CHECK-NEXT:   .quad _property_access3
 ; CHECK-NEXT:   .quad 24
+; CHECK-NEXT:   .quad 1
 ; CHECK-NEXT:   .quad _anyreg_test1
 ; CHECK-NEXT:   .quad 56
+; CHECK-NEXT:   .quad 1
 ; CHECK-NEXT:   .quad _anyreg_test2
 ; CHECK-NEXT:   .quad 56
+; CHECK-NEXT:   .quad 1
 ; CHECK-NEXT:   .quad _patchpoint_spilldef
 ; CHECK-NEXT:   .quad 56
+; CHECK-NEXT:   .quad 1
 ; CHECK-NEXT:   .quad _patchpoint_spillargs
 ; CHECK-NEXT:   .quad 88
+; CHECK-NEXT:   .quad 1
 
 ; No constants
 
 ; Callsites
 ; test
 ; CHECK-LABEL:  .long   L{{.*}}-_test
 ; CHECK-NEXT:   .short  0
 ; 3 locations

llvm/trunk/test/CodeGen/X86/patchpoint-invoke.ll

 ; Verify that the unwind data covers the entire patchpoint region:
 ; CHECK-NEXT: .long .Ltmp0-[[FUNC_BEGIN]]
 ; CHECK-NEXT: .long [[PP_END]]-.Ltmp0
 
 
 ; Verify that the stackmap section got emitted:
 ; CHECK-LABEL: __LLVM_StackMaps:
 ; Header
-; CHECK-NEXT:   .byte 1
+; CHECK-NEXT:   .byte 2
 ; CHECK-NEXT:   .byte 0
 ; CHECK-NEXT:   .short 0
 ; Num Functions
 ; CHECK-NEXT:   .long 1
 ; Num LargeConstants
 ; CHECK-NEXT:   .long 0
 ; Num Callsites
 ; CHECK-NEXT:   .long 1
 ; CHECK-NEXT:   .quad patchpoint_invoke
 
 
 declare void @llvm.experimental.stackmap(i64, i32, ...)
 declare void @llvm.experimental.patchpoint.void(i64, i32, i8*, i32, ...)
 declare i64 @llvm.experimental.patchpoint.i64(i64, i32, i8*, i32, ...)
 declare i32 @__gxx_personality_v0(...)

llvm/trunk/test/CodeGen/X86/stackmap-fast-isel.ll

 ; RUN: llc < %s -mtriple=x86_64-apple-darwin -mcpu=corei7                             | FileCheck %s
 ; RUN: llc < %s -mtriple=x86_64-apple-darwin -mcpu=corei7 -fast-isel -fast-isel-abort=1 | FileCheck %s
 
 ; CHECK-LABEL:  .section  __LLVM_STACKMAPS,__llvm_stackmaps
 ; CHECK-NEXT:  __LLVM_StackMaps:
 ; Header
-; CHECK-NEXT:   .byte 1
+; CHECK-NEXT:   .byte 2
 ; CHECK-NEXT:   .byte 0
 ; CHECK-NEXT:   .short 0
 ; Num Functions
 ; CHECK-NEXT:   .long 4
 ; Num LargeConstants
 ; CHECK-NEXT:   .long 3
 ; Num Callsites
 ; CHECK-NEXT:   .long 7
 
 ; Functions and stack size
 ; CHECK-NEXT:   .quad _constantargs
 ; CHECK-NEXT:   .quad 8
+; CHECK-NEXT:   .quad 1
 ; CHECK-NEXT:   .quad _liveConstant
 ; CHECK-NEXT:   .quad 8
+; CHECK-NEXT:   .quad 1
 ; CHECK-NEXT:   .quad _directFrameIdx
 ; CHECK-NEXT:   .quad 40
+; CHECK-NEXT:   .quad 1
 ; CHECK-NEXT:   .quad _longid
 ; CHECK-NEXT:   .quad 8
+; CHECK-NEXT:   .quad 4
 
 ; Large Constants
 ; CHECK-NEXT:   .quad   2147483648
 ; CHECK-NEXT:   .quad   4294967295
 ; CHECK-NEXT:   .quad   4294967296
 
 ; Callsites
 ; Constant arguments

llvm/trunk/test/CodeGen/X86/stackmap-large-constants.ll

 ; RUN: llc < %s -mtriple=x86_64-apple-darwin | FileCheck %s
 
 ; CHECK-LABEL:  .section  __LLVM_STACKMAPS,__llvm_stackmaps
 ; CHECK-NEXT: __LLVM_StackMaps:
 ; version
-; CHECK-NEXT:   .byte 1
+; CHECK-NEXT:   .byte 2
 ; reserved
 ; CHECK-NEXT:   .byte 0
 ; reserved
 ; CHECK-NEXT:   .short  0
 ; # functions
 ; CHECK-NEXT:   .long 2
 ; # constants
 ; CHECK-NEXT:   .long 2
 ; # records
 ; CHECK-NEXT:   .long 2
 ; function address & stack size
 ; CHECK-NEXT:   .quad _foo
 ; CHECK-NEXT:   .quad 8
+; CHECK-NEXT:   .quad 1
 ; function address & stack size
 ; CHECK-NEXT:   .quad _bar
 ; CHECK-NEXT:   .quad 8
+; CHECK-NEXT:   .quad 1
 
 ; Constants Array:
 ; CHECK-NEXT:   .quad 9223372036854775807
 ; CHECK-NEXT:   .quad -9223372036854775808
 
 ; Patchpoint ID
 ; CHECK-NEXT:   .quad 0
 ; Instruction offset

llvm/trunk/test/CodeGen/X86/stackmap-liveness.ll

 ; RUN: llc < %s -mtriple=x86_64-apple-darwin -mcpu=corei7-avx -enable-patchpoint-liveness=false | FileCheck %s
 ; RUN: llc < %s -mtriple=x86_64-apple-darwin -mcpu=corei7-avx                                   | FileCheck -check-prefix=PATCH %s
 ;
 ; Note: Print verbose stackmaps using -debug-only=stackmaps.
 
 ; CHECK-LABEL:  .section  __LLVM_STACKMAPS,__llvm_stackmaps
 ; CHECK-NEXT:   __LLVM_StackMaps:
 ; Header
-; CHECK-NEXT:   .byte 1
+; CHECK-NEXT:   .byte 2
 ; CHECK-NEXT:   .byte 0
 ; CHECK-NEXT:   .short 0
 ; Num Functions
 ; CHECK-NEXT:   .long 2
 ; Num LargeConstants
 ; CHECK-NEXT:   .long   0
 ; Num Callsites
 ; CHECK-NEXT:   .long   5
 
 ; Functions and stack size
 ; CHECK-NEXT:   .quad _stackmap_liveness
 ; CHECK-NEXT:   .quad 8
+; CHECK-NEXT:   .quad 3
 ; CHECK-NEXT:   .quad _mixed_liveness
 ; CHECK-NEXT:   .quad 8
+; CHECK-NEXT:   .quad 2
 
 define void @stackmap_liveness() {
 entry:
   %a1 = call <2 x double> asm sideeffect "", "={xmm2}"() nounwind
 ; StackMap 1 (no liveness information available)
 ; CHECK-LABEL:  .long L{{.*}}-_stackmap_liveness
 ; CHECK-NEXT:   .short  0
 ; CHECK-NEXT:   .short  0

llvm/trunk/test/CodeGen/X86/stackmap.ll

 ; RUN: llc < %s -mtriple=x86_64-apple-darwin -mcpu=corei7 | FileCheck %s
 ;
 ; Note: Print verbose stackmaps using -debug-only=stackmaps.
 
 ; CHECK-LABEL:  .section  __LLVM_STACKMAPS,__llvm_stackmaps
 ; CHECK-NEXT:  __LLVM_StackMaps:
 ; Header
-; CHECK-NEXT:   .byte 1
+; CHECK-NEXT:   .byte 2
 ; CHECK-NEXT:   .byte 0
 ; CHECK-NEXT:   .short 0
 ; Num Functions
 ; CHECK-NEXT:   .long 16
 ; Num LargeConstants
 ; CHECK-NEXT:   .long 3
 ; Num Callsites
 ; CHECK-NEXT:   .long 20
 
 ; Functions and stack size
 ; CHECK-NEXT:   .quad _constantargs
 ; CHECK-NEXT:   .quad 8
+; CHECK-NEXT:   .quad 1
 ; CHECK-NEXT:   .quad _osrinline
 ; CHECK-NEXT:   .quad 24
+; CHECK-NEXT:   .quad 1
 ; CHECK-NEXT:   .quad _osrcold
 ; CHECK-NEXT:   .quad 8
+; CHECK-NEXT:   .quad 1
 ; CHECK-NEXT:   .quad _propertyRead
 ; CHECK-NEXT:   .quad 8
+; CHECK-NEXT:   .quad 1
 ; CHECK-NEXT:   .quad _propertyWrite
 ; CHECK-NEXT:   .quad 8
+; CHECK-NEXT:   .quad 1
 ; CHECK-NEXT:   .quad _jsVoidCall
 ; CHECK-NEXT:   .quad 8
+; CHECK-NEXT:   .quad 1
 ; CHECK-NEXT:   .quad _jsIntCall
 ; CHECK-NEXT:   .quad 8
+; CHECK-NEXT:   .quad 1
 ; CHECK-NEXT:   .quad _spilledValue
 ; CHECK-NEXT:   .quad 56
+; CHECK-NEXT:   .quad 1
 ; CHECK-NEXT:   .quad _spilledStackMapValue
 ; CHECK-NEXT:   .quad 56
+; CHECK-NEXT:   .quad 1
 ; CHECK-NEXT:   .quad _spillSubReg
 ; CHECK-NEXT:   .quad 56
+; CHECK-NEXT:   .quad 1
 ; CHECK-NEXT:   .quad _subRegOffset
 ; CHECK-NEXT:   .quad 56
+; CHECK-NEXT:   .quad 1
 ; CHECK-NEXT:   .quad _liveConstant
 ; CHECK-NEXT:   .quad 8
+; CHECK-NEXT:   .quad 1
 ; CHECK-NEXT:   .quad _directFrameIdx
 ; CHECK-NEXT:   .quad 56
+; CHECK-NEXT:   .quad 2
 ; CHECK-NEXT:   .quad _longid
 ; CHECK-NEXT:   .quad 8
+; CHECK-NEXT:   .quad 4
 ; CHECK-NEXT:   .quad _clobberScratch
 ; CHECK-NEXT:   .quad 56
+; CHECK-NEXT:   .quad 1
 ; CHECK-NEXT:   .quad _needsStackRealignment
 ; CHECK-NEXT:   .quad -1
+; CHECK-NEXT:   .quad 1
 
 ; Large Constants
 ; CHECK-NEXT:   .quad   2147483648
 ; CHECK-NEXT:   .quad   4294967295
 ; CHECK-NEXT:   .quad   4294967296
 
 ; Callsites
 ; Constant arguments

llvm/trunk/test/CodeGen/X86/statepoint-allocas.ll

 }
 
 declare token @llvm.experimental.gc.statepoint.p0f_i1f(i64, i32, i1 ()*, i32, i32, ...)
 
 
 ; CHECK-LABEL: .section .llvm_stackmaps
 ; CHECK-NEXT:  __LLVM_StackMaps:
 ; Header
-; CHECK-NEXT:   .byte 1
+; CHECK-NEXT:   .byte 2
 ; CHECK-NEXT:   .byte 0
 ; CHECK-NEXT:   .short 0
 ; Num Functions
 ; CHECK-NEXT:   .long 2
 ; Num LargeConstants
 ; CHECK-NEXT:   .long 0
 ; Num Callsites
 ; CHECK-NEXT:   .long 2
 
 ; Functions and stack size
 ; CHECK-NEXT:   .quad test
 ; CHECK-NEXT:   .quad 8
+; CHECK-NEXT:   .quad 1
 ; CHECK-NEXT:   .quad test2
 ; CHECK-NEXT:   .quad 8
+; CHECK-NEXT:   .quad 1
 
 ; Large Constants
 ; Statepoint ID only
 ; CHECK: .quad  0
 
 ; Callsites
 ; The GC one
 ; CHECK: .long  .Ltmp1-test

 ; CHECK: .byte  8
 ; CHECK: .short 7
 ; CHECK: .long  0
 
 ; No Padding or LiveOuts
 ; CHECK: .short 0
 ; CHECK: .short 0
 ; CHECK: .p2align 3
-

llvm/trunk/test/CodeGen/X86/statepoint-stackmap-format.ll

 
 declare token @llvm.experimental.gc.statepoint.p0f_i1f(i64, i32, i1 ()*, i32, i32, ...)
 declare i1 @llvm.experimental.gc.result.i1(token)
 declare i32 addrspace(1)* @llvm.experimental.gc.relocate.p1i32(token, i32, i32) #3
 
 ; CHECK-LABEL: .section .llvm_stackmaps
 ; CHECK-NEXT:  __LLVM_StackMaps:
 ; Header
-; CHECK-NEXT:   .byte 1
+; CHECK-NEXT:   .byte 2
 ; CHECK-NEXT:   .byte 0
 ; CHECK-NEXT:   .short 0
 ; Num Functions
 ; CHECK-NEXT:   .long 3
 ; Num LargeConstants
 ; CHECK-NEXT:   .long 0
 ; Num Callsites
 ; CHECK-NEXT:   .long 3
 
 ; Functions and stack size
 ; CHECK-NEXT:   .quad test
 ; CHECK-NEXT:   .quad 40
+; CHECK-NEXT:   .quad 1
 ; CHECK-NEXT:   .quad test_derived_arg
 ; CHECK-NEXT:   .quad 40
+; CHECK-NEXT:   .quad 1
 ; CHECK-NEXT:   .quad test_id
 ; CHECK-NEXT:   .quad 8
+; CHECK-NEXT:   .quad 1
 
 ;
 ; test
 ;
 
 ; Statepoint ID
 ; CHECK-NEXT: .quad 0
 

 ; CHECK: .byte  8
 ; CHECK: .short 0
 ; CHECK: .long  0
 
 ; No padding or LiveOuts
 ; CHECK: .short 0
 ; CHECK: .short 0
 ; CHECK: .p2align 3
-

llvm/trunk/test/Object/stackmap-dump.test

 RUN: llvm-readobj -stackmap %p/Inputs/stackmap-test.macho-x86-64 | FileCheck %s
 
-CHECK:      LLVM StackMap Version: 1
-CHECK-NEXT: Num Functions: 1
-CHECK-NEXT:   Function address: 0, stack size: 16
-CHECK-NEXT: Num Constants: 1
-CHECK-NEXT:   #1: 10000000000
-CHECK-NEXT: Num Records: 1
-CHECK-NEXT:   Record ID: 2, instruction offset: 1
-CHECK-NEXT:     5 locations:
+; Note: the macho object file in this test was generated in the following way:
+; llc -mtriple=x86_64-apple-darwin %p/test/CodeGen/X86/stackmap.ll -o stackmap.s
+; clang -c stackmap.s -o %p/test/Object/Inputs/stackmap-test.macho-x86-64
+
+CHECK: LLVM StackMap Version: 2
+CHECK-NEXT: Num Functions: 16
+CHECK-NEXT:   Function address: 0, stack size: 8, callsite record count: 1
+CHECK-NEXT:   Function address: 0, stack size: 24, callsite record count: 1
+CHECK-NEXT:   Function address: 0, stack size: 8, callsite record count: 1
+CHECK-NEXT:   Function address: 0, stack size: 8, callsite record count: 1
+CHECK-NEXT:   Function address: 0, stack size: 8, callsite record count: 1
+CHECK-NEXT:   Function address: 0, stack size: 8, callsite record count: 1
+CHECK-NEXT:   Function address: 0, stack size: 8, callsite record count: 1
+CHECK-NEXT:   Function address: 0, stack size: 56, callsite record count: 1
+CHECK-NEXT:   Function address: 0, stack size: 56, callsite record count: 1
+CHECK-NEXT:   Function address: 0, stack size: 56, callsite record count: 1
+CHECK-NEXT:   Function address: 0, stack size: 56, callsite record count: 1
+CHECK-NEXT:   Function address: 0, stack size: 8, callsite record count: 1
+CHECK-NEXT:   Function address: 0, stack size: 56, callsite record count: 2
+CHECK-NEXT:   Function address: 0, stack size: 8, callsite record count: 4
+CHECK-NEXT:   Function address: 0, stack size: 56, callsite record count: 1
+CHECK-NEXT:   Function address: 0, stack size: 18446744073709551615, callsite record count: 1
+CHECK-NEXT: Num Constants: 3
+CHECK-NEXT:   #1: 2147483648
+CHECK-NEXT:   #2: 4294967295
+CHECK-NEXT:   #3: 4294967296
+CHECK-NEXT: Num Records: 20
+CHECK-NEXT:   Record ID: 1, instruction offset: 4
+CHECK-NEXT:     12 locations:
+CHECK-NEXT:       #1: Constant 4294967295
+CHECK-NEXT:       #2: Constant 4294967295
+CHECK-NEXT:       #3: Constant 65536
+CHECK-NEXT:       #4: Constant 2000000000
+CHECK-NEXT:       #5: Constant 2147483647
+CHECK-NEXT:       #6: Constant 4294967295
+CHECK-NEXT:       #7: Constant 4294967295
+CHECK-NEXT:       #8: Constant 0
+CHECK-NEXT:       #9: ConstantIndex #0 (2147483648)
+CHECK-NEXT:       #10: ConstantIndex #1 (4294967295)
+CHECK-NEXT:       #11: ConstantIndex #2 (4294967296)
+CHECK-NEXT:       #12: Constant 4294967295
+CHECK-NEXT:     1 live-outs: [ R#7 (8-bytes) ]
+
+CHECK:        Record ID: 3, instruction offset: 22
+CHECK-NEXT:     2 locations:
+CHECK-NEXT:       #1: Register R#3
+CHECK-NEXT:       #2: Register R#14
+CHECK-NEXT:     0 live-outs: [ ]
+
+CHECK:        Record ID: 4, instruction offset: 10
+CHECK-NEXT:     2 locations:
 CHECK-NEXT:       #1: Register R#5
-CHECK-NEXT:       #2: Constant 10
-CHECK-NEXT:       #3: ConstantIndex #0 (10000000000)
-CHECK-NEXT:       #4: Direct R#4 + -8
-CHECK-NEXT:       #5: Indirect [R#6 + -16]
+CHECK-NEXT:       #2: Register R#4
+CHECK-NEXT:     0 live-outs: [ ]
+
+CHECK:        Record ID: 5, instruction offset: 4
+CHECK-NEXT:     2 locations:
+CHECK-NEXT:       #1: Register R#0
+CHECK-NEXT:       #2: Register R#5
+CHECK-NEXT:     2 live-outs: [ R#0 (8-bytes) R#7 (8-bytes) ]
+
+CHECK:        Record ID: 6, instruction offset: 4
+CHECK-NEXT:     2 locations:
+CHECK-NEXT:       #1: Register R#4
+CHECK-NEXT:       #2: Register R#2
 CHECK-NEXT:     1 live-outs: [ R#7 (8-bytes) ]
+
+CHECK:        Record ID: 7, instruction offset: 10
+CHECK-NEXT:     2 locations:
+CHECK-NEXT:       #1: Register R#2
+CHECK-NEXT:       #2: Register R#8
+CHECK-NEXT:     1 live-outs: [ R#7 (8-bytes) ]
+
+CHECK:        Record ID: 8, instruction offset: 10
+CHECK-NEXT:     2 locations:
+CHECK-NEXT:       #1: Register R#2
+CHECK-NEXT:       #2: Register R#8
+CHECK-NEXT:     2 live-outs: [ R#0 (8-bytes) R#7 (8-bytes) ]
+
+CHECK:        Record ID: 11, instruction offset: 42
+CHECK-NEXT:     17 locations:
+CHECK-NEXT:       #1: Register R#9
+CHECK-NEXT:       #2: Register R#14
+CHECK-NEXT:       #3: Register R#10
+CHECK-NEXT:       #4: Register R#3
+CHECK-NEXT:       #5: Register R#0
+CHECK-NEXT:       #6: Register R#13
+CHECK-NEXT:       #7: Register R#12
+CHECK-NEXT:       #8: Register R#15
+CHECK-NEXT:       #9: Indirect [R#6 + 72]
+CHECK-NEXT:       #10: Indirect [R#6 + 80]
+CHECK-NEXT:       #11: Indirect [R#6 + 88]
+CHECK-NEXT:       #12: Indirect [R#6 + 96]
+CHECK-NEXT:       #13: Indirect [R#6 + 104]
+CHECK-NEXT:       #14: Indirect [R#6 + 112]
+CHECK-NEXT:       #15: Indirect [R#6 + 120]
+CHECK-NEXT:       #16: Indirect [R#6 + 128]
+CHECK-NEXT:       #17: Indirect [R#6 + 136]
+CHECK-NEXT:     1 live-outs: [ R#7 (8-bytes) ]
+
+CHECK:        Record ID: 12, instruction offset: 62
+CHECK-NEXT:     17 locations:
+CHECK-NEXT:       #1: Register R#0
+CHECK-NEXT:       #2: Register R#14
+CHECK-NEXT:       #3: Register R#10
+CHECK-NEXT:       #4: Register R#9
+CHECK-NEXT:       #5: Register R#8
+CHECK-NEXT:       #6: Register R#4
+CHECK-NEXT:       #7: Register R#1
+CHECK-NEXT:       #8: Register R#2
+CHECK-NEXT:       #9: Register R#5
+CHECK-NEXT:       #10: Register R#3
+CHECK-NEXT:       #11: Register R#13
+CHECK-NEXT:       #12: Register R#12
+CHECK-NEXT:       #13: Register R#15
+CHECK-NEXT:       #14: Indirect [R#6 + 112]
+CHECK-NEXT:       #15: Indirect [R#6 + 120]
+CHECK-NEXT:       #16: Indirect [R#6 + 128]
+CHECK-NEXT:       #17: Indirect [R#6 + 136]
+CHECK-NEXT:     0 live-outs: [ ]
+
+CHECK:        Record ID: 13, instruction offset: 50
+CHECK-NEXT:     1 locations:
+CHECK-NEXT:       #1: Indirect [R#6 + -48]
+CHECK-NEXT:     0 live-outs: [ ]
+
+CHECK:        Record ID: 14, instruction offset: 24
+CHECK-NEXT:     2 locations:
+CHECK-NEXT:       #1: Register R#0
+CHECK-NEXT:       #2: Register R#3
+CHECK-NEXT:     0 live-outs: [ ]
+
+CHECK:        Record ID: 15, instruction offset: 4
+CHECK-NEXT:     1 locations:
+CHECK-NEXT:       #1: Constant 33
+CHECK-NEXT:     0 live-outs: [ ]
+
+CHECK:        Record ID: 16, instruction offset: 32
+CHECK-NEXT:     1 locations:
+CHECK-NEXT:       #1: Direct R#6 + -32
+CHECK-NEXT:     0 live-outs: [ ]
+
+CHECK:        Record ID: 17, instruction offset: 32
+CHECK-NEXT:     2 locations:
+CHECK-NEXT:       #1: Direct R#6 + -8
+CHECK-NEXT:       #2: Direct R#6 + -40
+CHECK-NEXT:     1 live-outs: [ R#7 (8-bytes) ]
+
+CHECK:        Record ID: 4294967295, instruction offset: 4
+CHECK-NEXT:     0 locations:
+CHECK-NEXT:     0 live-outs: [ ]
+
+CHECK:        Record ID: 4294967296, instruction offset: 4
+CHECK-NEXT:     0 locations:
+CHECK-NEXT:     0 live-outs: [ ]
+
+CHECK:        Record ID: 9223372036854775807, instruction offset: 4
+CHECK-NEXT:     0 locations:
+CHECK-NEXT:     0 live-outs: [ ]
+
+CHECK:        Record ID: 18446744073709551615, instruction offset: 4
+CHECK-NEXT:     0 locations:
+CHECK-NEXT:     1 live-outs: [ R#7 (8-bytes) ]
+
+CHECK:        Record ID: 16, instruction offset: 18
+CHECK-NEXT:     1 locations:
+CHECK-NEXT:       #1: Indirect [R#6 + -44]
+CHECK-NEXT:     0 live-outs: [ ]
+
+CHECK:        Record ID: 0, instruction offset: 26
+CHECK-NEXT:     0 locations:
+CHECK-NEXT:     0 live-outs: [ ]

llvm/trunk/tools/llvm-readobj/COFFDumper.cpp

void COFFDumper::printStackMap() const {
   StackMapSection.getContents(StackMapContents);
   ArrayRef<uint8_t> StackMapContentsArray(
       reinterpret_cast<const uint8_t*>(StackMapContents.data()),
       StackMapContents.size());
 
   if (Obj->isLittleEndian())
     prettyPrintStackMap(
                       llvm::outs(),
-                      StackMapV1Parser<support::little>(StackMapContentsArray));
+                      StackMapV2Parser<support::little>(StackMapContentsArray));
   else
     prettyPrintStackMap(llvm::outs(),
-                        StackMapV1Parser<support::big>(StackMapContentsArray));
+                        StackMapV2Parser<support::big>(StackMapContentsArray));
 }
 
 void llvm::dumpCodeViewMergedTypes(
     ScopedPrinter &Writer, llvm::codeview::MemoryTypeTableBuilder &CVTypes) {
   // Flatten it first, then run our dumper on it.
   ListScope S(Writer, "MergedTypeStream");
   SmallString<0> Buf;
   CVTypes.ForEachRecord([&](TypeIndex TI, StringRef Record) {
     Buf.append(Record.begin(), Record.end());
   });
   CVTypeDumper CVTD(&Writer, opts::CodeViewSubsectionBytes);
   if (auto EC = CVTD.dump({Buf.str().bytes_begin(), Buf.str().bytes_end()})) {
     Writer.flush();
     error(llvm::errorToErrorCode(std::move(EC)));
   }
 }

llvm/trunk/tools/llvm-readobj/ELFDumper.cpp

template <class ELFT> void ELFDumper<ELFT>::printStackMap() const {
 
   if (!StackMapSection)
     return;
 
   StringRef StackMapContents;
   ArrayRef<uint8_t> StackMapContentsArray =
       unwrapOrError(Obj->getSectionContents(StackMapSection));
 
-  prettyPrintStackMap(llvm::outs(), StackMapV1Parser<ELFT::TargetEndianness>(
+  prettyPrintStackMap(llvm::outs(), StackMapV2Parser<ELFT::TargetEndianness>(
                                         StackMapContentsArray));
 }
 
 template <class ELFT> void ELFDumper<ELFT>::printGroupSections() {
   ELFDumperStyle->printGroupSections(Obj);
 }
 
 static inline void printFields(formatted_raw_ostream &OS, StringRef Str1,

llvm/trunk/tools/llvm-readobj/MachODumper.cpp

void MachODumper::printStackMap() const {
   StackMapSection.getContents(StackMapContents);
   ArrayRef<uint8_t> StackMapContentsArray(
       reinterpret_cast<const uint8_t*>(StackMapContents.data()),
       StackMapContents.size());
 
   if (Obj->isLittleEndian())
      prettyPrintStackMap(
                       llvm::outs(),
-                      StackMapV1Parser<support::little>(StackMapContentsArray));
+                      StackMapV2Parser<support::little>(StackMapContentsArray));
   else
      prettyPrintStackMap(llvm::outs(),
-                         StackMapV1Parser<support::big>(StackMapContentsArray));
+                         StackMapV2Parser<support::big>(StackMapContentsArray));
 }
 
 void MachODumper::printMachODataInCode() {
   for (const auto &Load : Obj->load_commands()) {
     if (Load.C.cmd  == MachO::LC_DATA_IN_CODE) {
       MachO::linkedit_data_command LLC = Obj->getLinkeditDataLoadCommand(Load);
       DictScope Group(W, "DataInCode");
       W.printNumber("Data offset", LLC.dataoff);

llvm/trunk/tools/llvm-readobj/StackMapPrinter.h

 void prettyPrintStackMap(OStreamT &OS, const StackMapParserT &SMP) {
 
   OS << "LLVM StackMap Version: " << SMP.getVersion()
      << "\nNum Functions: " << SMP.getNumFunctions();
 
   // Functions:
   for (const auto &F : SMP.functions())
     OS << "\n  Function address: " << F.getFunctionAddress()
-       << ", stack size: " << F.getStackSize();
+       << ", stack size: " << F.getStackSize()
+       << ", callsite record count: " << F.getRecordCount();
 
   // Constants:
   OS << "\nNum Constants: " << SMP.getNumConstants();
   unsigned ConstantIndex = 0;
   for (const auto &C : SMP.constants())
     OS << "\n  #" << ++ConstantIndex << ": " << C.getValue();
 
   // Records: