long ReadMethod(LogReader _reader, LogBufferHeader _bufferHeader)
{
return(_bufferHeader.CurrentMethod += _reader.ReadSLeb128());
}
long ReadPointer(LogReader _reader, LogBufferHeader _bufferHeader)
{
var ptr = _reader.ReadSLeb128() + _bufferHeader.PointerBase;
return(StreamHeader.PointerSize == sizeof(long) ? ptr : ptr& 0xffffffffL);
}
long ReadObject(LogReader _reader, LogBufferHeader _bufferHeader)
{
return(_reader.ReadSLeb128() + _bufferHeader.ObjectBase << 3);
}
LogEvent ReadEvent(LogReader _reader, LogBufferHeader _bufferHeader)
{
var type = _reader.ReadByte();
var basicType = (LogEventType)(type & 0xf);
var extType = (LogEventType)(type & 0xf0);
var _time = ReadTime(_reader, _bufferHeader);
if (minimalTime > _time)
{
minimalTime = _time;
_time = 0;
}
else
{
_time = _time - minimalTime;
}
LogEvent ev = null;
switch (basicType)
{
case LogEventType.Allocation:
switch (extType)
{
case LogEventType.AllocationBacktrace:
case LogEventType.AllocationNoBacktrace:
ev = new AllocationEvent {
VTablePointer = StreamHeader.FormatVersion >= 15 ? ReadPointer(_reader, _bufferHeader) : 0,
ObjectPointer = ReadObject(_reader, _bufferHeader),
ObjectSize = (long)_reader.ReadULeb128(),
Backtrace = ReadBacktrace(extType == LogEventType.AllocationBacktrace, _reader, _bufferHeader),
};
break;
default:
throw new LogException($"Invalid extended event type ({extType}).");
}
break;
case LogEventType.GC:
switch (extType)
{
case LogEventType.GCEvent:
ev = new GCEvent {
Type = (LogGCEvent)_reader.ReadByte(),
Generation = _reader.ReadByte(),
};
break;
case LogEventType.GCResize:
ev = new GCResizeEvent {
NewSize = (long)_reader.ReadULeb128(),
};
break;
case LogEventType.GCMove: {
var list = new long[(int)_reader.ReadULeb128()];
for (var i = 0; i < list.Length; i++)
{
list[i] = ReadObject(_reader, _bufferHeader);
}
ev = new GCMoveEvent {
OldObjectPointers = list.Where((_, i) => i % 2 == 0).ToArray(),
NewObjectPointers = list.Where((_, i) => i % 2 != 0).ToArray(),
};
break;
}
case LogEventType.GCHandleCreationNoBacktrace:
case LogEventType.GCHandleCreationBacktrace:
ev = new GCHandleCreationEvent {
Type = (LogGCHandleType)_reader.ReadULeb128(),
Handle = (long)_reader.ReadULeb128(),
ObjectPointer = ReadObject(_reader, _bufferHeader),
Backtrace = ReadBacktrace(extType == LogEventType.GCHandleCreationBacktrace, _reader, _bufferHeader),
};
break;
case LogEventType.GCHandleDeletionNoBacktrace:
case LogEventType.GCHandleDeletionBacktrace:
ev = new GCHandleDeletionEvent {
Type = (LogGCHandleType)_reader.ReadULeb128(),
Handle = (long)_reader.ReadULeb128(),
Backtrace = ReadBacktrace(extType == LogEventType.GCHandleDeletionBacktrace, _reader, _bufferHeader),
};
break;
case LogEventType.GCFinalizeBegin:
ev = new GCFinalizeBeginEvent();
break;
case LogEventType.GCFinalizeEnd:
ev = new GCFinalizeEndEvent();
break;
case LogEventType.GCFinalizeObjectBegin:
ev = new GCFinalizeObjectBeginEvent {
ObjectPointer = ReadObject(_reader, _bufferHeader),
};
break;
case LogEventType.GCFinalizeObjectEnd:
ev = new GCFinalizeObjectEndEvent {
ObjectPointer = ReadObject(_reader, _bufferHeader),
};
break;
default:
throw new LogException($"Invalid extended event type ({extType}).");
}
break;
case LogEventType.Metadata: {
var load = false;
var unload = false;
switch (extType)
{
case LogEventType.MetadataExtra:
break;
case LogEventType.MetadataEndLoad:
load = true;
break;
case LogEventType.MetadataEndUnload:
unload = true;
break;
default:
throw new LogException($"Invalid extended event type ({extType}).");
}
var metadataType = (LogMetadataType)_reader.ReadByte();
switch (metadataType)
{
case LogMetadataType.Class:
if (load)
{
ev = new ClassLoadEvent {
ClassPointer = ReadPointer(_reader, _bufferHeader),
ImagePointer = ReadPointer(_reader, _bufferHeader),
Name = _reader.ReadCString(),
};
}
else
{
throw new LogException("Invalid class metadata event.");
}
break;
case LogMetadataType.Image:
if (load)
{
ev = new ImageLoadEvent {
ImagePointer = ReadPointer(_reader, _bufferHeader),
Name = _reader.ReadCString(),
};
}
else if (unload)
{
ev = new ImageUnloadEvent {
ImagePointer = ReadPointer(_reader, _bufferHeader),
Name = _reader.ReadCString(),
};
}
else
{
throw new LogException("Invalid image metadata event.");
}
break;
case LogMetadataType.Assembly:
if (load)
{
ev = new AssemblyLoadEvent {
AssemblyPointer = ReadPointer(_reader, _bufferHeader),
ImagePointer = StreamHeader.FormatVersion >= 14 ? ReadPointer(_reader, _bufferHeader) : 0,
Name = _reader.ReadCString(),
};
}
else if (unload)
{
ev = new AssemblyUnloadEvent {
AssemblyPointer = ReadPointer(_reader, _bufferHeader),
ImagePointer = StreamHeader.FormatVersion >= 14 ? ReadPointer(_reader, _bufferHeader) : 0,
Name = _reader.ReadCString(),
};
}
else
{
throw new LogException("Invalid assembly metadata event.");
}
break;
case LogMetadataType.AppDomain:
if (load)
{
ev = new AppDomainLoadEvent {
AppDomainId = ReadPointer(_reader, _bufferHeader),
};
}
else if (unload)
{
ev = new AppDomainUnloadEvent {
AppDomainId = ReadPointer(_reader, _bufferHeader),
};
}
else
{
ev = new AppDomainNameEvent {
AppDomainId = ReadPointer(_reader, _bufferHeader),
Name = _reader.ReadCString(),
};
}
break;
case LogMetadataType.Thread:
if (load)
{
ev = new ThreadStartEvent {
ThreadId = ReadPointer(_reader, _bufferHeader),
};
}
else if (unload)
{
ev = new ThreadEndEvent {
ThreadId = ReadPointer(_reader, _bufferHeader),
};
}
else
{
ev = new ThreadNameEvent {
ThreadId = ReadPointer(_reader, _bufferHeader),
Name = _reader.ReadCString(),
};
}
break;
case LogMetadataType.Context:
if (load)
{
ev = new ContextLoadEvent {
ContextId = ReadPointer(_reader, _bufferHeader),
AppDomainId = ReadPointer(_reader, _bufferHeader),
};
}
else if (unload)
{
ev = new ContextUnloadEvent {
ContextId = ReadPointer(_reader, _bufferHeader),
AppDomainId = ReadPointer(_reader, _bufferHeader),
};
}
else
{
throw new LogException("Invalid context metadata event.");
}
break;
case LogMetadataType.VTable:
if (load)
{
ev = new VTableLoadEvent {
VTablePointer = ReadPointer(_reader, _bufferHeader),
AppDomainId = ReadPointer(_reader, _bufferHeader),
ClassPointer = ReadPointer(_reader, _bufferHeader),
};
}
else
{
throw new LogException("Invalid VTable metadata event.");
}
break;
default:
throw new LogException($"Invalid metadata type ({metadataType}).");
}
break;
}
case LogEventType.Method:
switch (extType)
{
case LogEventType.MethodLeave:
ev = new LeaveEvent {
MethodPointer = ReadMethod(_reader, _bufferHeader),
};
break;
case LogEventType.MethodEnter:
ev = new EnterEvent {
MethodPointer = ReadMethod(_reader, _bufferHeader),
};
break;
case LogEventType.MethodLeaveExceptional:
ev = new ExceptionalLeaveEvent {
MethodPointer = ReadMethod(_reader, _bufferHeader),
};
break;
case LogEventType.MethodJit:
ev = new JitEvent {
MethodPointer = ReadMethod(_reader, _bufferHeader),
CodePointer = ReadPointer(_reader, _bufferHeader),
CodeSize = (long)_reader.ReadULeb128(),
Name = _reader.ReadCString(),
};
break;
default:
throw new LogException($"Invalid extended event type ({extType}).");
}
break;
case LogEventType.Exception:
switch (extType)
{
case LogEventType.ExceptionThrowNoBacktrace:
case LogEventType.ExceptionThrowBacktrace:
ev = new ThrowEvent {
ObjectPointer = ReadObject(_reader, _bufferHeader),
Backtrace = ReadBacktrace(extType == LogEventType.ExceptionThrowBacktrace, _reader, _bufferHeader),
};
break;
case LogEventType.ExceptionClause:
ev = new ExceptionClauseEvent {
Type = (LogExceptionClause)_reader.ReadByte(),
Index = (long)_reader.ReadULeb128(),
MethodPointer = ReadMethod(_reader, _bufferHeader),
ObjectPointer = StreamHeader.FormatVersion >= 14 ? ReadObject(_reader, _bufferHeader) : 0,
};
break;
default:
throw new LogException($"Invalid extended event type ({extType}).");
}
break;
case LogEventType.Monitor:
if (StreamHeader.FormatVersion < 14)
{
if (extType.HasFlag(LogEventType.MonitorBacktrace))
{
extType = LogEventType.MonitorBacktrace;
}
else
{
extType = LogEventType.MonitorNoBacktrace;
}
}
switch (extType)
{
case LogEventType.MonitorNoBacktrace:
case LogEventType.MonitorBacktrace:
ev = new MonitorEvent {
Event = StreamHeader.FormatVersion >= 14 ?
(LogMonitorEvent)_reader.ReadByte() :
(LogMonitorEvent)((((byte)type & 0xf0) >> 4) & 0x3),
ObjectPointer = ReadObject(_reader, _bufferHeader),
Backtrace = ReadBacktrace(extType == LogEventType.MonitorBacktrace, _reader, _bufferHeader),
};
break;
default:
throw new LogException($"Invalid extended event type ({extType}).");
}
break;
case LogEventType.Heap:
switch (extType)
{
case LogEventType.HeapBegin:
ev = new HeapBeginEvent();
break;
case LogEventType.HeapEnd:
ev = new HeapEndEvent();
break;
case LogEventType.HeapObject: {
HeapObjectEvent hoe = new HeapObjectEvent {
ObjectPointer = ReadObject(_reader, _bufferHeader),
VTablePointer = StreamHeader.FormatVersion >= 15 ? ReadPointer(_reader, _bufferHeader) : 0,
ObjectSize = (long)_reader.ReadULeb128(),
};
var listTo = new long[(int)_reader.ReadULeb128()];
var listAt = new ushort[listTo.Length];
for (var i = 0; i < listTo.Length; i++)
{
listAt[i] = (ushort)_reader.ReadULeb128();
listTo[i] = ReadObject(_reader, _bufferHeader);
}
hoe.ReferencesAt = listAt;
hoe.ReferencesTo = listTo;
ev = hoe;
break;
}
case LogEventType.HeapRoots: {
var hre = new HeapRootsEvent();
var list = new HeapRootsEvent.HeapRoot[(int)_reader.ReadULeb128()];
for (var i = 0; i < list.Length; i++)
{
list[i] = new HeapRootsEvent.HeapRoot {
AddressPointer = StreamHeader.FormatVersion >= 15 ? ReadPointer(_reader, _bufferHeader) : 0,
ObjectPointer = ReadObject(_reader, _bufferHeader)
};
}
hre.Roots = list;
ev = hre;
break;
}
case LogEventType.HeapRootRegister:
ev = new HeapRootRegisterEvent {
RootPointer = ReadPointer(_reader, _bufferHeader),
RootSize = (long)_reader.ReadULeb128(),
Source = (LogHeapRootSource)_reader.ReadByte(),
Key = ReadPointer(_reader, _bufferHeader),
Name = _reader.ReadCString(),
};
break;
case LogEventType.HeapRootUnregister:
ev = new HeapRootUnregisterEvent {
RootPointer = ReadPointer(_reader, _bufferHeader),
};
break;
default:
throw new LogException($"Invalid extended event type ({extType}).");
}
break;
case LogEventType.Sample:
switch (extType)
{
case LogEventType.SampleHit:
if (StreamHeader.FormatVersion < 14)
{
// Read SampleType (always set to .Cycles) for versions < 14
_reader.ReadByte();
}
ev = new SampleHitEvent {
ThreadId = ReadPointer(_reader, _bufferHeader),
UnmanagedBacktrace = ReadBacktrace(true, _reader, _bufferHeader, false),
ManagedBacktrace = ReadBacktrace(true, _reader, _bufferHeader).Reverse().ToArray(),
};
break;
case LogEventType.SampleUnmanagedSymbol:
ev = new UnmanagedSymbolEvent {
CodePointer = ReadPointer(_reader, _bufferHeader),
CodeSize = (long)_reader.ReadULeb128(),
Name = _reader.ReadCString(),
};
break;
case LogEventType.SampleUnmanagedBinary:
ev = new UnmanagedBinaryEvent {
SegmentPointer = StreamHeader.FormatVersion >= 14 ? ReadPointer(_reader, _bufferHeader) : _reader.ReadSLeb128(),
SegmentOffset = (long)_reader.ReadULeb128(),
SegmentSize = (long)_reader.ReadULeb128(),
FileName = _reader.ReadCString(),
};
break;
case LogEventType.SampleCounterDescriptions: {
var cde = new CounterDescriptionsEvent();
var list = new CounterDescriptionsEvent.CounterDescription[(int)_reader.ReadULeb128()];
for (var i = 0; i < list.Length; i++)
{
var section = (LogCounterSection)_reader.ReadULeb128();
list[i] = new CounterDescriptionsEvent.CounterDescription {
Section = section,
SectionName = section == LogCounterSection.User ? _reader.ReadCString() : null,
CounterName = _reader.ReadCString(),
Type = StreamHeader.FormatVersion < 15 ? (LogCounterType)_reader.ReadByte() : (LogCounterType)_reader.ReadULeb128(),
Unit = StreamHeader.FormatVersion < 15 ? (LogCounterUnit)_reader.ReadByte() : (LogCounterUnit)_reader.ReadULeb128(),
Variance = StreamHeader.FormatVersion < 15 ? (LogCounterVariance)_reader.ReadByte() : (LogCounterVariance)_reader.ReadULeb128(),
Index = (long)_reader.ReadULeb128(),
};
}
cde.Descriptions = list;
ev = cde;
break;
}
case LogEventType.SampleCounters: {
var cse = new CounterSamplesEvent();
var list = new List <CounterSamplesEvent.CounterSample>();
while (true)
{
var index = (long)_reader.ReadULeb128();
if (index == 0)
{
break;
}
var counterType = StreamHeader.FormatVersion < 15 ? (LogCounterType)_reader.ReadByte() : (LogCounterType)_reader.ReadULeb128();
object value = null;
switch (counterType)
{
case LogCounterType.String:
value = _reader.ReadByte() == 1 ? _reader.ReadCString() : null;
break;
case LogCounterType.Int32:
case LogCounterType.Word:
case LogCounterType.Int64:
case LogCounterType.Interval:
value = _reader.ReadSLeb128();
break;
case LogCounterType.UInt32:
case LogCounterType.UInt64:
value = _reader.ReadULeb128();
break;
case LogCounterType.Double:
value = _reader.ReadDouble();
break;
default:
throw new LogException($"Invalid counter type ({counterType}).");
}
list.Add(new CounterSamplesEvent.CounterSample {
Index = index,
Type = counterType,
Value = value,
});
}
cse.Samples = list;
ev = cse;
break;
}
default:
throw new LogException($"Invalid extended event type ({extType}).");
}
break;
case LogEventType.Runtime:
switch (extType)
{
case LogEventType.RuntimeJitHelper: {
var helperType = (LogJitHelper)_reader.ReadByte();
ev = new JitHelperEvent {
Type = helperType,
BufferPointer = ReadPointer(_reader, _bufferHeader),
BufferSize = (long)_reader.ReadULeb128(),
Name = helperType == LogJitHelper.SpecificTrampoline ? _reader.ReadCString() : null,
};
break;
}
default:
throw new LogException($"Invalid extended event type ({extType}).");
}
break;
case LogEventType.Meta:
switch (extType)
{
case LogEventType.MetaSynchronizationPoint:
ev = new SynchronizationPointEvent {
Type = (LogSynchronizationPoint)_reader.ReadByte(),
};
break;
default:
throw new LogException($"Invalid extended event type ({extType}).");
}
break;
default:
throw new LogException($"Invalid basic event type ({basicType}).");
}
ev.Timestamp = _time;
return(ev);
}