[rustc.git] / src / compiler-rt / lib / profile / InstrProfilingWriter.c

/*===- InstrProfilingWriter.c - Write instrumentation to a file or buffer -===*\
|*
|*                     The LLVM Compiler Infrastructure
|*
|* This file is distributed under the University of Illinois Open Source
|* License. See LICENSE.TXT for details.
|*
\*===----------------------------------------------------------------------===*/

#include "InstrProfiling.h"
#include "InstrProfilingInternal.h"
#ifdef _MSC_VER
/* For _alloca */
#include <malloc.h>
#endif
#include <string.h>

#define INSTR_PROF_VALUE_PROF_DATA
#include "InstrProfData.inc"

COMPILER_RT_VISIBILITY void (*FreeHook)(void *) = NULL;
static ProfBufferIO TheBufferIO;
#define VP_BUFFER_SIZE 8 * 1024
static uint8_t BufferIOBuffer[VP_BUFFER_SIZE];
static InstrProfValueData VPDataArray[16];
static uint32_t VPDataArraySize = sizeof(VPDataArray) / sizeof(*VPDataArray);

COMPILER_RT_VISIBILITY uint8_t *DynamicBufferIOBuffer = 0;
COMPILER_RT_VISIBILITY uint32_t VPBufferSize = 0;

/* The buffer writer is reponsponsible in keeping writer state
 * across the call.
 */
COMPILER_RT_VISIBILITY uint32_t lprofBufferWriter(ProfDataIOVec *IOVecs,
                                                  uint32_t NumIOVecs,
                                                  void **WriterCtx) {
  uint32_t I;
  char **Buffer = (char **)WriterCtx;
  for (I = 0; I < NumIOVecs; I++) {
    size_t Length = IOVecs[I].ElmSize * IOVecs[I].NumElm;
    memcpy(*Buffer, IOVecs[I].Data, Length);
    *Buffer += Length;
  }
  return 0;
}

static void llvmInitBufferIO(ProfBufferIO *BufferIO, WriterCallback FileWriter,
                             void *File, uint8_t *Buffer, uint32_t BufferSz) {
  BufferIO->File = File;
  BufferIO->FileWriter = FileWriter;
  BufferIO->BufferStart = Buffer;
  BufferIO->BufferSz = BufferSz;
  BufferIO->CurOffset = 0;
}

COMPILER_RT_VISIBILITY ProfBufferIO *
lprofCreateBufferIO(WriterCallback FileWriter, void *File) {
  uint8_t *Buffer = DynamicBufferIOBuffer;
  uint32_t BufferSize = VPBufferSize;
  if (!Buffer) {
    Buffer = &BufferIOBuffer[0];
    BufferSize = sizeof(BufferIOBuffer);
  }
  llvmInitBufferIO(&TheBufferIO, FileWriter, File, Buffer, BufferSize);
  return &TheBufferIO;
}

COMPILER_RT_VISIBILITY void lprofDeleteBufferIO(ProfBufferIO *BufferIO) {
  if (DynamicBufferIOBuffer) {
    FreeHook(DynamicBufferIOBuffer);
    DynamicBufferIOBuffer = 0;
    VPBufferSize = 0;
  }
}

COMPILER_RT_VISIBILITY int
lprofBufferIOWrite(ProfBufferIO *BufferIO, const uint8_t *Data, uint32_t Size) {
  /* Buffer is not large enough, it is time to flush.  */
  if (Size + BufferIO->CurOffset > BufferIO->BufferSz) {
    if (lprofBufferIOFlush(BufferIO) != 0)
      return -1;
  }
  /* Special case, bypass the buffer completely. */
  ProfDataIOVec IO[] = {{Data, sizeof(uint8_t), Size}};
  if (Size > BufferIO->BufferSz) {
    if (BufferIO->FileWriter(IO, 1, &BufferIO->File))
      return -1;
  } else {
    /* Write the data to buffer */
    uint8_t *Buffer = BufferIO->BufferStart + BufferIO->CurOffset;
    lprofBufferWriter(IO, 1, (void **)&Buffer);
    BufferIO->CurOffset = Buffer - BufferIO->BufferStart;
  }
  return 0;
}

COMPILER_RT_VISIBILITY int lprofBufferIOFlush(ProfBufferIO *BufferIO) {
  if (BufferIO->CurOffset) {
    ProfDataIOVec IO[] = {
        {BufferIO->BufferStart, sizeof(uint8_t), BufferIO->CurOffset}};
    if (BufferIO->FileWriter(IO, 1, &BufferIO->File))
      return -1;
    BufferIO->CurOffset = 0;
  }
  return 0;
}

/* Write out value profile data for function specified with \c Data.
 * The implementation does not use the method \c serializeValueProfData
 * which depends on dynamic memory allocation. In this implementation,
 * value profile data is written out to \c BufferIO piecemeal.
 */
static int writeOneValueProfData(ProfBufferIO *BufferIO,
                                 VPDataReaderType *VPDataReader,
                                 const __llvm_profile_data *Data) {
  unsigned I, NumValueKinds = 0;
  ValueProfData VPHeader;
  uint8_t *SiteCountArray[IPVK_Last + 1];

  for (I = 0; I <= IPVK_Last; I++) {
    if (!Data->NumValueSites[I])
      SiteCountArray[I] = 0;
    else {
      uint32_t Sz =
          VPDataReader->GetValueProfRecordHeaderSize(Data->NumValueSites[I]) -
          offsetof(ValueProfRecord, SiteCountArray);
      /* Only use alloca for this small byte array to avoid excessive
       * stack growth.  */
      SiteCountArray[I] = (uint8_t *)COMPILER_RT_ALLOCA(Sz);
      memset(SiteCountArray[I], 0, Sz);
    }
  }

  /* If NumValueKinds returned is 0, there is nothing to write, report
     success and return. This should match the raw profile reader's behavior. */
  if (!(NumValueKinds = VPDataReader->InitRTRecord(Data, SiteCountArray)))
    return 0;

  /* First write the header structure. */
  VPHeader.TotalSize = VPDataReader->GetValueProfDataSize();
  VPHeader.NumValueKinds = NumValueKinds;
  if (lprofBufferIOWrite(BufferIO, (const uint8_t *)&VPHeader,
                         sizeof(ValueProfData)))
    return -1;

  /* Make sure nothing else needs to be written before value profile
   * records. */
  if ((void *)VPDataReader->GetFirstValueProfRecord(&VPHeader) !=
      (void *)(&VPHeader + 1))
    return -1;

  /* Write out the value profile record for each value kind
   * one by one. */
  for (I = 0; I <= IPVK_Last; I++) {
    uint32_t J;
    ValueProfRecord RecordHeader;
    /* The size of the value prof record header without counting the
     * site count array .*/
    uint32_t RecordHeaderSize = offsetof(ValueProfRecord, SiteCountArray);
    uint32_t SiteCountArraySize;

    if (!Data->NumValueSites[I])
      continue;

    /* Write out the record header.  */
    RecordHeader.Kind = I;
    RecordHeader.NumValueSites = Data->NumValueSites[I];
    if (lprofBufferIOWrite(BufferIO, (const uint8_t *)&RecordHeader,
                           RecordHeaderSize))
      return -1;

    /* Write out the site value count array including padding space. */
    SiteCountArraySize =
        VPDataReader->GetValueProfRecordHeaderSize(Data->NumValueSites[I]) -
        RecordHeaderSize;
    if (lprofBufferIOWrite(BufferIO, SiteCountArray[I], SiteCountArraySize))
      return -1;

    /* Write out the value profile data for each value site.  */
    for (J = 0; J < Data->NumValueSites[I]; J++) {
      uint32_t NRead, NRemain;
      ValueProfNode *NextStartNode = 0;
      NRemain = VPDataReader->GetNumValueDataForSite(I, J);
      if (!NRemain)
        continue;
      /* Read and write out value data in small chunks till it is done. */
      do {
        NRead = (NRemain > VPDataArraySize ? VPDataArraySize : NRemain);
        NextStartNode =
            VPDataReader->GetValueData(I, /* ValueKind */
                                       J, /* Site */
                                       &VPDataArray[0], NextStartNode, NRead);
        if (lprofBufferIOWrite(BufferIO, (const uint8_t *)&VPDataArray[0],
                               NRead * sizeof(InstrProfValueData)))
          return -1;
        NRemain -= NRead;
      } while (NRemain != 0);
    }
  }
  /* All done report success.  */
  return 0;
}

static int writeValueProfData(WriterCallback Writer, void *WriterCtx,
                              VPDataReaderType *VPDataReader,
                              const __llvm_profile_data *DataBegin,
                              const __llvm_profile_data *DataEnd) {
  ProfBufferIO *BufferIO;
  const __llvm_profile_data *DI = 0;

  if (!VPDataReader)
    return 0;

  BufferIO = lprofCreateBufferIO(Writer, WriterCtx);

  for (DI = DataBegin; DI < DataEnd; DI++) {
    if (writeOneValueProfData(BufferIO, VPDataReader, DI))
      return -1;
  }

  if (lprofBufferIOFlush(BufferIO) != 0)
    return -1;
  lprofDeleteBufferIO(BufferIO);

  return 0;
}

COMPILER_RT_VISIBILITY int lprofWriteData(WriterCallback Writer,
                                          void *WriterCtx,
                                          VPDataReaderType *VPDataReader) {
  /* Match logic in __llvm_profile_write_buffer(). */
  const __llvm_profile_data *DataBegin = __llvm_profile_begin_data();
  const __llvm_profile_data *DataEnd = __llvm_profile_end_data();
  const uint64_t *CountersBegin = __llvm_profile_begin_counters();
  const uint64_t *CountersEnd = __llvm_profile_end_counters();
  const char *NamesBegin = __llvm_profile_begin_names();
  const char *NamesEnd = __llvm_profile_end_names();
  return lprofWriteDataImpl(Writer, WriterCtx, DataBegin, DataEnd,
                            CountersBegin, CountersEnd, VPDataReader,
                            NamesBegin, NamesEnd);
}

COMPILER_RT_VISIBILITY int
lprofWriteDataImpl(WriterCallback Writer, void *WriterCtx,
                   const __llvm_profile_data *DataBegin,
                   const __llvm_profile_data *DataEnd,
                   const uint64_t *CountersBegin, const uint64_t *CountersEnd,
                   VPDataReaderType *VPDataReader, const char *NamesBegin,
                   const char *NamesEnd) {

  /* Calculate size of sections. */
  const uint64_t DataSize = __llvm_profile_get_data_size(DataBegin, DataEnd);
  const uint64_t CountersSize = CountersEnd - CountersBegin;
  const uint64_t NamesSize = NamesEnd - NamesBegin;
  const uint64_t Padding = __llvm_profile_get_num_padding_bytes(NamesSize);

  /* Enough zeroes for padding. */
  const char Zeroes[sizeof(uint64_t)] = {0};

  /* Create the header. */
  __llvm_profile_header Header;

  if (!DataSize)
    return 0;

/* Initialize header structure.  */
#define INSTR_PROF_RAW_HEADER(Type, Name, Init) Header.Name = Init;
#include "InstrProfData.inc"

  /* Write the data. */
  ProfDataIOVec IOVec[] = {{&Header, sizeof(__llvm_profile_header), 1},
                           {DataBegin, sizeof(__llvm_profile_data), DataSize},
                           {CountersBegin, sizeof(uint64_t), CountersSize},
                           {NamesBegin, sizeof(uint8_t), NamesSize},
                           {Zeroes, sizeof(uint8_t), Padding}};
  if (Writer(IOVec, sizeof(IOVec) / sizeof(*IOVec), &WriterCtx))
    return -1;

  return writeValueProfData(Writer, WriterCtx, VPDataReader, DataBegin,
                            DataEnd);
}
Commit	Line	Data
3157f602 XL	1	/===- InstrProfilingWriter.c - Write instrumentation to a file or buffer -===\
	2	\|*
	3	\|* The LLVM Compiler Infrastructure
	4	\|*
	5	\|* This file is distributed under the University of Illinois Open Source
	6	\|* License. See LICENSE.TXT for details.
	7	\|*
	8	\===----------------------------------------------------------------------===/
	9
	10	#include "InstrProfiling.h"
	11	#include "InstrProfilingInternal.h"
5bcae85e SL	12	#ifdef _MSC_VER
	13	/* For _alloca */
	14	#include <malloc.h>
	15	#endif
3157f602 XL	16	#include <string.h>
	17
	18	#define INSTR_PROF_VALUE_PROF_DATA
	19	#include "InstrProfData.inc"
5bcae85e SL	20
	21	COMPILER_RT_VISIBILITY void (FreeHook)(void ) = NULL;
	22	static ProfBufferIO TheBufferIO;
	23	#define VP_BUFFER_SIZE 8 * 1024
	24	static uint8_t BufferIOBuffer[VP_BUFFER_SIZE];
	25	static InstrProfValueData VPDataArray[16];
	26	static uint32_t VPDataArraySize = sizeof(VPDataArray) / sizeof(*VPDataArray);
	27
	28	COMPILER_RT_VISIBILITY uint8_t *DynamicBufferIOBuffer = 0;
	29	COMPILER_RT_VISIBILITY uint32_t VPBufferSize = 0;
3157f602 XL	30
	31	/* The buffer writer is reponsponsible in keeping writer state
	32	* across the call.
	33	*/
5bcae85e SL	34	COMPILER_RT_VISIBILITY uint32_t lprofBufferWriter(ProfDataIOVec *IOVecs,
	35	uint32_t NumIOVecs,
	36	void **WriterCtx) {
3157f602 XL	37	uint32_t I;
	38	char Buffer = (char )WriterCtx;
	39	for (I = 0; I < NumIOVecs; I++) {
	40	size_t Length = IOVecs[I].ElmSize * IOVecs[I].NumElm;
	41	memcpy(*Buffer, IOVecs[I].Data, Length);
	42	*Buffer += Length;
	43	}
	44	return 0;
	45	}
	46
	47	static void llvmInitBufferIO(ProfBufferIO *BufferIO, WriterCallback FileWriter,
	48	void File, uint8_t Buffer, uint32_t BufferSz) {
	49	BufferIO->File = File;
	50	BufferIO->FileWriter = FileWriter;
	51	BufferIO->BufferStart = Buffer;
	52	BufferIO->BufferSz = BufferSz;
	53	BufferIO->CurOffset = 0;
	54	}
	55
	56	COMPILER_RT_VISIBILITY ProfBufferIO *
5bcae85e SL	57	lprofCreateBufferIO(WriterCallback FileWriter, void *File) {
	58	uint8_t *Buffer = DynamicBufferIOBuffer;
	59	uint32_t BufferSize = VPBufferSize;
3157f602	60	if (!Buffer) {
5bcae85e SL	61	Buffer = &BufferIOBuffer[0];
5bcae85e SL	62	BufferSize = sizeof(BufferIOBuffer);
3157f602	63	}
5bcae85e SL	64	llvmInitBufferIO(&TheBufferIO, FileWriter, File, Buffer, BufferSize);
5bcae85e SL	65	return &TheBufferIO;
3157f602 XL	66	}
3157f602 XL	67
5bcae85e SL	68	COMPILER_RT_VISIBILITY void lprofDeleteBufferIO(ProfBufferIO *BufferIO) {
	69	if (DynamicBufferIOBuffer) {
	70	FreeHook(DynamicBufferIOBuffer);
	71	DynamicBufferIOBuffer = 0;
	72	VPBufferSize = 0;
	73	}
3157f602 XL	74	}
	75
	76	COMPILER_RT_VISIBILITY int
5bcae85e	77	lprofBufferIOWrite(ProfBufferIO BufferIO, const uint8_t Data, uint32_t Size) {
3157f602 XL	78	/* Buffer is not large enough, it is time to flush. */
3157f602 XL	79	if (Size + BufferIO->CurOffset > BufferIO->BufferSz) {
5bcae85e SL	80	if (lprofBufferIOFlush(BufferIO) != 0)
5bcae85e SL	81	return -1;
3157f602 XL	82	}
	83	/* Special case, bypass the buffer completely. */
	84	ProfDataIOVec IO[] = {{Data, sizeof(uint8_t), Size}};
	85	if (Size > BufferIO->BufferSz) {
	86	if (BufferIO->FileWriter(IO, 1, &BufferIO->File))
	87	return -1;
	88	} else {
	89	/* Write the data to buffer */
	90	uint8_t *Buffer = BufferIO->BufferStart + BufferIO->CurOffset;
5bcae85e	91	lprofBufferWriter(IO, 1, (void **)&Buffer);
3157f602 XL	92	BufferIO->CurOffset = Buffer - BufferIO->BufferStart;
	93	}
	94	return 0;
	95	}
	96
5bcae85e	97	COMPILER_RT_VISIBILITY int lprofBufferIOFlush(ProfBufferIO *BufferIO) {
3157f602 XL	98	if (BufferIO->CurOffset) {
	99	ProfDataIOVec IO[] = {
	100	{BufferIO->BufferStart, sizeof(uint8_t), BufferIO->CurOffset}};
	101	if (BufferIO->FileWriter(IO, 1, &BufferIO->File))
	102	return -1;
	103	BufferIO->CurOffset = 0;
	104	}
	105	return 0;
	106	}
	107
5bcae85e SL	108	/* Write out value profile data for function specified with \c Data.
	109	* The implementation does not use the method \c serializeValueProfData
	110	* which depends on dynamic memory allocation. In this implementation,
	111	* value profile data is written out to \c BufferIO piecemeal.
	112	*/
	113	static int writeOneValueProfData(ProfBufferIO *BufferIO,
	114	VPDataReaderType *VPDataReader,
	115	const __llvm_profile_data *Data) {
	116	unsigned I, NumValueKinds = 0;
	117	ValueProfData VPHeader;
	118	uint8_t *SiteCountArray[IPVK_Last + 1];
	119
	120	for (I = 0; I <= IPVK_Last; I++) {
	121	if (!Data->NumValueSites[I])
	122	SiteCountArray[I] = 0;
	123	else {
	124	uint32_t Sz =
	125	VPDataReader->GetValueProfRecordHeaderSize(Data->NumValueSites[I]) -
	126	offsetof(ValueProfRecord, SiteCountArray);
	127	/* Only use alloca for this small byte array to avoid excessive
	128	* stack growth. */
	129	SiteCountArray[I] = (uint8_t *)COMPILER_RT_ALLOCA(Sz);
	130	memset(SiteCountArray[I], 0, Sz);
	131	}
	132	}
	133
	134	/* If NumValueKinds returned is 0, there is nothing to write, report
	135	success and return. This should match the raw profile reader's behavior. */
	136	if (!(NumValueKinds = VPDataReader->InitRTRecord(Data, SiteCountArray)))
	137	return 0;
	138
	139	/* First write the header structure. */
	140	VPHeader.TotalSize = VPDataReader->GetValueProfDataSize();
	141	VPHeader.NumValueKinds = NumValueKinds;
	142	if (lprofBufferIOWrite(BufferIO, (const uint8_t *)&VPHeader,
	143	sizeof(ValueProfData)))
	144	return -1;
	145
	146	/* Make sure nothing else needs to be written before value profile
	147	* records. */
	148	if ((void *)VPDataReader->GetFirstValueProfRecord(&VPHeader) !=
	149	(void *)(&VPHeader + 1))
	150	return -1;
	151
	152	/* Write out the value profile record for each value kind
	153	* one by one. */
	154	for (I = 0; I <= IPVK_Last; I++) {
	155	uint32_t J;
	156	ValueProfRecord RecordHeader;
	157	/* The size of the value prof record header without counting the
	158	* site count array .*/
	159	uint32_t RecordHeaderSize = offsetof(ValueProfRecord, SiteCountArray);
	160	uint32_t SiteCountArraySize;
	161
	162	if (!Data->NumValueSites[I])
	163	continue;
	164
	165	/* Write out the record header. */
	166	RecordHeader.Kind = I;
	167	RecordHeader.NumValueSites = Data->NumValueSites[I];
	168	if (lprofBufferIOWrite(BufferIO, (const uint8_t *)&RecordHeader,
	169	RecordHeaderSize))
	170	return -1;
	171
172	/* Write out the site value count array including padding space. */
173	SiteCountArraySize =
174	VPDataReader->GetValueProfRecordHeaderSize(Data->NumValueSites[I]) -
175	RecordHeaderSize;
176	if (lprofBufferIOWrite(BufferIO, SiteCountArray[I], SiteCountArraySize))
177	return -1;
178
179	/* Write out the value profile data for each value site. */
180	for (J = 0; J < Data->NumValueSites[I]; J++) {
181	uint32_t NRead, NRemain;
182	ValueProfNode *NextStartNode = 0;
183	NRemain = VPDataReader->GetNumValueDataForSite(I, J);
184	if (!NRemain)
185	continue;
186	/* Read and write out value data in small chunks till it is done. */
187	do {
188	NRead = (NRemain > VPDataArraySize ? VPDataArraySize : NRemain);
189	NextStartNode =
190	VPDataReader->GetValueData(I, /* ValueKind */
191	J, /* Site */
192	&VPDataArray[0], NextStartNode, NRead);
193	if (lprofBufferIOWrite(BufferIO, (const uint8_t *)&VPDataArray[0],
194	NRead * sizeof(InstrProfValueData)))
195	return -1;
196	NRemain -= NRead;
197	} while (NRemain != 0);
198	}
199	}
200	/* All done report success. */
201	return 0;
3157f602 XL	202	}
3157f602 XL	203
3157f602	204	static int writeValueProfData(WriterCallback Writer, void *WriterCtx,
5bcae85e SL	205	VPDataReaderType *VPDataReader,
	206	const __llvm_profile_data *DataBegin,
	207	const __llvm_profile_data *DataEnd) {
3157f602	208	ProfBufferIO *BufferIO;
5bcae85e	209	const __llvm_profile_data *DI = 0;
3157f602	210
5bcae85e	211	if (!VPDataReader)
3157f602 XL	212	return 0;
3157f602 XL	213
5bcae85e	214	BufferIO = lprofCreateBufferIO(Writer, WriterCtx);
3157f602	215
5bcae85e SL	216	for (DI = DataBegin; DI < DataEnd; DI++) {
5bcae85e SL	217	if (writeOneValueProfData(BufferIO, VPDataReader, DI))
3157f602 XL	218	return -1;
	219	}
	220
5bcae85e	221	if (lprofBufferIOFlush(BufferIO) != 0)
3157f602	222	return -1;
5bcae85e	223	lprofDeleteBufferIO(BufferIO);
3157f602 XL	224
	225	return 0;
	226	}
	227
5bcae85e SL	228	COMPILER_RT_VISIBILITY int lprofWriteData(WriterCallback Writer,
	229	void *WriterCtx,
	230	VPDataReaderType *VPDataReader) {
	231	/* Match logic in __llvm_profile_write_buffer(). */
	232	const __llvm_profile_data *DataBegin = __llvm_profile_begin_data();
	233	const __llvm_profile_data *DataEnd = __llvm_profile_end_data();
	234	const uint64_t *CountersBegin = __llvm_profile_begin_counters();
	235	const uint64_t *CountersEnd = __llvm_profile_end_counters();
	236	const char *NamesBegin = __llvm_profile_begin_names();
	237	const char *NamesEnd = __llvm_profile_end_names();
	238	return lprofWriteDataImpl(Writer, WriterCtx, DataBegin, DataEnd,
	239	CountersBegin, CountersEnd, VPDataReader,
	240	NamesBegin, NamesEnd);
	241	}
	242
	243	COMPILER_RT_VISIBILITY int
	244	lprofWriteDataImpl(WriterCallback Writer, void *WriterCtx,
	245	const __llvm_profile_data *DataBegin,
	246	const __llvm_profile_data *DataEnd,
	247	const uint64_t CountersBegin, const uint64_t CountersEnd,
	248	VPDataReaderType VPDataReader, const char NamesBegin,
	249	const char *NamesEnd) {
3157f602 XL	250
3157f602 XL	251	/* Calculate size of sections. */
5bcae85e	252	const uint64_t DataSize = __llvm_profile_get_data_size(DataBegin, DataEnd);
3157f602 XL	253	const uint64_t CountersSize = CountersEnd - CountersBegin;
	254	const uint64_t NamesSize = NamesEnd - NamesBegin;
	255	const uint64_t Padding = __llvm_profile_get_num_padding_bytes(NamesSize);
	256
	257	/* Enough zeroes for padding. */
	258	const char Zeroes[sizeof(uint64_t)] = {0};
	259
	260	/* Create the header. */
	261	__llvm_profile_header Header;
	262
	263	if (!DataSize)
	264	return 0;
	265
5bcae85e	266	/* Initialize header structure. */
3157f602 XL	267	#define INSTR_PROF_RAW_HEADER(Type, Name, Init) Header.Name = Init;
	268	#include "InstrProfData.inc"
	269
	270	/* Write the data. */
	271	ProfDataIOVec IOVec[] = {{&Header, sizeof(__llvm_profile_header), 1},
	272	{DataBegin, sizeof(__llvm_profile_data), DataSize},
	273	{CountersBegin, sizeof(uint64_t), CountersSize},
	274	{NamesBegin, sizeof(uint8_t), NamesSize},
	275	{Zeroes, sizeof(uint8_t), Padding}};
	276	if (Writer(IOVec, sizeof(IOVec) / sizeof(*IOVec), &WriterCtx))
	277	return -1;
	278
5bcae85e SL	279	return writeValueProfData(Writer, WriterCtx, VPDataReader, DataBegin,
5bcae85e SL	280	DataEnd);
3157f602	281	}