[XRay][tools] Support arg1 logging entries in the basic logging mode

[dberris]

Summary

The arg1 logging handler changed in compiler-rt to start writing a
different type for entries encountered when logging the first argument
of XRay-instrumented functions. This change allows the trace loader to
support reading these record types as well as prepare for when the
basic (naive) mode implementation starts writing down the argument
payloads.

Without this change, binaries with arg1 logging support enabled start
writing unreadable logs for any of the XRay tracing tools.

[pelikan]

lib/XRay/Trace.cpp

260–263 ↗

(On Diff #117691)

These wraps are not necessary, it fits 80 characters well.

295–296 ↗

(On Diff #117691)

These wraps are not necessary, it fits 80 characters well.

389–390 ↗

(On Diff #117691)

These wraps are not necessary, it fits 80 characters well.

423–433 ↗

(On Diff #117691)

These wraps are not necessary, it fits 80 characters well.

[dberris]

• fixup: undo intermediate clang-format atrefacts

[pelikan]

LGTM now. Let's see what breaks :-)

llvm/trunk/lib/XRay/Trace.cpp

Error loadNaiveFormatLog(StringRef Data, XRayFileHeader &FileHeader,
   //   (1)   uint8  : type
   //   (4)   sint32 : function id
   //   (8)   uint64 : tsc
   //   (4)   uint32 : thread id
   //   (12)  -      : padding
   for (auto S = Data.drop_front(32); !S.empty(); S = S.drop_front(32)) {
     DataExtractor RecordExtractor(S, true, 8);
     uint32_t OffsetPtr = 0;
+    switch (auto RecordType = RecordExtractor.getU16(&OffsetPtr)) {
+    case 0: { // Normal records.
       Records.emplace_back();
       auto &Record = Records.back();
-    Record.RecordType = RecordExtractor.getU16(&OffsetPtr);
+      Record.RecordType = RecordType;
       Record.CPU = RecordExtractor.getU8(&OffsetPtr);
       auto Type = RecordExtractor.getU8(&OffsetPtr);
       switch (Type) {
       case 0:
         Record.Type = RecordTypes::ENTER;
         break;
       case 1:
         Record.Type = RecordTypes::EXIT;
         break;
       case 2:
         Record.Type = RecordTypes::TAIL_EXIT;
         break;
+      case 3:
+        Record.Type = RecordTypes::ENTER_ARG;
+        break;
       default:
         return make_error<StringError>(
             Twine("Unknown record type '") + Twine(int{Type}) + "'",
             std::make_error_code(std::errc::executable_format_error));
       }
       Record.FuncId = RecordExtractor.getSigned(&OffsetPtr, sizeof(int32_t));
       Record.TSC = RecordExtractor.getU64(&OffsetPtr);
       Record.TId = RecordExtractor.getU32(&OffsetPtr);
+      break;
+    }
+    case 1: { // Arg payload record.
+      auto &Record = Records.back();
+      // Advance two bytes to avoid padding.
+      OffsetPtr += 2;
+      int32_t FuncId = RecordExtractor.getSigned(&OffsetPtr, sizeof(int32_t));
+      auto TId = RecordExtractor.getU32(&OffsetPtr);
+      if (Record.FuncId != FuncId || Record.TId != TId)
+        return make_error<StringError>(
+            Twine("Corrupted log, found payload following non-matching "
+                  "function + thread record. Record for ") +
+                Twine(Record.FuncId) + " != " + Twine(FuncId),
+            std::make_error_code(std::errc::executable_format_error));
+      // Advance another four bytes to avoid padding.
+      OffsetPtr += 4;
+      auto Arg = RecordExtractor.getU64(&OffsetPtr);
+      Record.CallArgs.push_back(Arg);
+      break;
+    }
+    default:
+      return make_error<StringError>(
+          Twine("Unknown record type == ") + Twine(RecordType),
+          std::make_error_code(std::errc::executable_format_error));
+    }
   }
   return Error::success();
 }
 
 /// When reading from a Flight Data Recorder mode log, metadata records are
 /// sparse compared to packed function records, so we must maintain state as we
 /// read through the sequence of entries. This allows the reader to denormalize
 /// the CPUId and Thread Id onto each Function Record and transform delta
Error processCustomEventMarker(FDRState &State, uint8_t RecordFirstByte,
                                size_t &RecordSize) {
   // We can encounter a CustomEventMarker anywhere in the log, so we can handle
   // it regardless of the expectation. However, we do set the expectation to
   // read a set number of fixed bytes, as described in the metadata.
   uint32_t OffsetPtr = 1; // Read after the first byte.
   uint32_t DataSize = RecordExtractor.getU32(&OffsetPtr);
   uint64_t TSC = RecordExtractor.getU64(&OffsetPtr);
 
-  // FIXME: Actually represent the record through the API. For now we only skip
-  // through the data.
+  // FIXME: Actually represent the record through the API. For now we only
+  // skip through the data.
   (void)TSC;
   RecordSize = 16 + DataSize;
   return Error::success();
 }
 
 /// State transition when a CallArgumentRecord is encountered.
 Error processFDRCallArgumentRecord(FDRState &State, uint8_t RecordFirstByte,
                                    DataExtractor &RecordExtractor,
Error loadYAMLLog(StringRef Data, XRayFileHeader &FileHeader,
   if (FileHeader.Version != 1)
     return make_error<StringError>(
         Twine("Unsupported XRay file version: ") + Twine(FileHeader.Version),
         std::make_error_code(std::errc::invalid_argument));
 
   Records.clear();
   std::transform(Trace.Records.begin(), Trace.Records.end(),
                  std::back_inserter(Records), [&](const YAMLXRayRecord &R) {
-                   return XRayRecord{R.RecordType, R.CPU, R.Type,
-                                     R.FuncId,     R.TSC, R.TId, R.CallArgs};
+                   return XRayRecord{R.RecordType, R.CPU, R.Type,    R.FuncId,
+                                     R.TSC,        R.TId, R.CallArgs};
                  });
   return Error::success();
 }
 } // namespace
 
 Expected<Trace> llvm::xray::loadTraceFile(StringRef Filename, bool Sort) {
   int Fd;
   if (auto EC = sys::fs::openFileForRead(Filename, Fd)) {

llvm/trunk/test/tools/llvm-xray/X86/convert-basic-arg1-to-yaml.txt

+; RUN: llvm-xray convert %S/Inputs/naive-with-arg1-entries.xray -f=yaml -o - | FileCheck %s
+
+; CHECK:      ---
+; CHECK-NEXT: header:
+; CHECK-NEXT:   version:         2
+; CHECK-NEXT:   type:            0
+; CHECK-NEXT:   constant-tsc:    true
+; CHECK-NEXT:   nonstop-tsc:     true
+; CHECK-NEXT:   cycle-frequency: 3500000000
+; CHECK-NEXT: records:
+; CHECK-NEXT:   - { type: 0, func-id: 1, function: '1', cpu: 17, thread: 8715, kind: function-enter, tsc: 22555670288232728 }
+; CHECK-NEXT:   - { type: 0, func-id: 1, function: '1', cpu: 17, thread: 8715, kind: function-exit, tsc: 22555670288334784 }
+; CHECK-NEXT:   - { type: 0, func-id: 2, function: '2', args: [ 1 ], cpu: 17, thread: 8715, kind: function-enter-arg, tsc: 22555670288335768 }
+; CHECK-NEXT:   - { type: 0, func-id: 2, function: '2', cpu: 17, thread: 8715, kind: function-exit, tsc: 22555670288365224 }
+; CHECK-NEXT: ...