[XRay] Use std::errc::invalid_argument instead of std::errc::bad_message

[kongyi]

Summary

This change should appease the mingw32 builds.

Similar to r293725.

[srhines]

LGTM, but please wait for dberris approval.

[MaskRay]

LG. std::errc::bad_message EBADMSG is used rarely, in STREAMS (which Linux chose not to implement; FreeBSD has very basic implementation) and very few network functions.

[dberris]

LGTM -- just FTR, since I missed this the first time around.

Thanks!

llvm/trunk/lib/XRay/RecordInitializer.cpp

Error RecordInitializer::visit(BufferExtents &R) {
   if (!E.isValidOffsetForDataOfSize(OffsetPtr, sizeof(uint64_t)))
     return createStringError(std::make_error_code(std::errc::bad_address),
                              "Invalid offset for a buffer extent (%d).",
                              OffsetPtr);
 
   auto PreReadOffset = OffsetPtr;
   R.Size = E.getU64(&OffsetPtr);
   if (PreReadOffset == OffsetPtr)
-    return createStringError(std::make_error_code(std::errc::bad_message),
+    return createStringError(std::make_error_code(std::errc::invalid_argument),
                              "Cannot read buffer extent at offset %d.",
                              OffsetPtr);
 
   OffsetPtr += MetadataRecord::kMetadataBodySize - (OffsetPtr - PreReadOffset);
   return Error::success();
 }
 
 Error RecordInitializer::visit(WallclockRecord &R) {
   if (!E.isValidOffsetForDataOfSize(OffsetPtr,
                                     MetadataRecord::kMetadataBodySize))
     return createStringError(std::make_error_code(std::errc::bad_address),
                              "Invalid offset for a wallclock record (%d).",
                              OffsetPtr);
   auto BeginOffset = OffsetPtr;
   auto PreReadOffset = OffsetPtr;
   R.Seconds = E.getU64(&OffsetPtr);
   if (OffsetPtr == PreReadOffset)
     return createStringError(
-        std::make_error_code(std::errc::bad_message),
+        std::make_error_code(std::errc::invalid_argument),
         "Cannot read wall clock 'seconds' field at offset %d.", OffsetPtr);
 
   PreReadOffset = OffsetPtr;
   R.Nanos = E.getU32(&OffsetPtr);
   if (OffsetPtr == PreReadOffset)
     return createStringError(
-        std::make_error_code(std::errc::bad_message),
+        std::make_error_code(std::errc::invalid_argument),
         "Cannot read wall clock 'nanos' field at offset %d.", OffsetPtr);
 
   // Align to metadata record size boundary.
   assert(OffsetPtr - BeginOffset <= MetadataRecord::kMetadataBodySize);
   OffsetPtr += MetadataRecord::kMetadataBodySize - (OffsetPtr - BeginOffset);
   return Error::success();
 }
 
 Error RecordInitializer::visit(NewCPUIDRecord &R) {
   if (!E.isValidOffsetForDataOfSize(OffsetPtr,
                                     MetadataRecord::kMetadataBodySize))
     return createStringError(std::make_error_code(std::errc::bad_address),
                              "Invalid offset for a new cpu id record (%d).",
                              OffsetPtr);
   auto BeginOffset = OffsetPtr;
   auto PreReadOffset = OffsetPtr;
   R.CPUId = E.getU16(&OffsetPtr);
   if (OffsetPtr == PreReadOffset)
-    return createStringError(std::make_error_code(std::errc::bad_message),
+    return createStringError(std::make_error_code(std::errc::invalid_argument),
                              "Cannot read CPU id at offset %d.", OffsetPtr);
 
   PreReadOffset = OffsetPtr;
   R.TSC = E.getU64(&OffsetPtr);
   if (OffsetPtr == PreReadOffset)
-    return createStringError(std::make_error_code(std::errc::bad_message),
+    return createStringError(std::make_error_code(std::errc::invalid_argument),
                              "Cannot read CPU TSC at offset %d.", OffsetPtr);
 
   OffsetPtr += MetadataRecord::kMetadataBodySize - (OffsetPtr - BeginOffset);
   return Error::success();
 }
 
 Error RecordInitializer::visit(TSCWrapRecord &R) {
   if (!E.isValidOffsetForDataOfSize(OffsetPtr,
                                     MetadataRecord::kMetadataBodySize))
     return createStringError(std::make_error_code(std::errc::bad_address),
                              "Invalid offset for a new TSC wrap record (%d).",
                              OffsetPtr);
 
   auto PreReadOffset = OffsetPtr;
   R.BaseTSC = E.getU64(&OffsetPtr);
   if (PreReadOffset == OffsetPtr)
-    return createStringError(std::make_error_code(std::errc::bad_message),
+    return createStringError(std::make_error_code(std::errc::invalid_argument),
                              "Cannot read TSC wrap record at offset %d.",
                              OffsetPtr);
 
   OffsetPtr += MetadataRecord::kMetadataBodySize - (OffsetPtr - PreReadOffset);
   return Error::success();
 }
 
 Error RecordInitializer::visit(CustomEventRecord &R) {
   if (!E.isValidOffsetForDataOfSize(OffsetPtr,
                                     MetadataRecord::kMetadataBodySize))
     return createStringError(std::make_error_code(std::errc::bad_address),
                              "Invalid offset for a custom event record (%d).",
                              OffsetPtr);
 
   auto BeginOffset = OffsetPtr;
   auto PreReadOffset = OffsetPtr;
   R.Size = E.getSigned(&OffsetPtr, sizeof(int32_t));
   if (PreReadOffset == OffsetPtr)
     return createStringError(
-        std::make_error_code(std::errc::bad_message),
+        std::make_error_code(std::errc::invalid_argument),
         "Cannot read a custom event record size field offset %d.", OffsetPtr);
 
   PreReadOffset = OffsetPtr;
   R.TSC = E.getU64(&OffsetPtr);
   if (PreReadOffset == OffsetPtr)
     return createStringError(
-        std::make_error_code(std::errc::bad_message),
+        std::make_error_code(std::errc::invalid_argument),
         "Cannot read a custom event TSC field at offset %d.", OffsetPtr);
 
   OffsetPtr += MetadataRecord::kMetadataBodySize - (OffsetPtr - BeginOffset);
 
   // Next we read in a fixed chunk of data from the given offset.
   if (!E.isValidOffsetForDataOfSize(OffsetPtr, R.Size))
     return createStringError(
         std::make_error_code(std::errc::bad_address),
         "Cannot read %d bytes of custom event data from offset %d.", R.Size,
         OffsetPtr);
 
   std::vector<uint8_t> Buffer;
   Buffer.resize(R.Size);
   if (E.getU8(&OffsetPtr, Buffer.data(), R.Size) != Buffer.data())
     return createStringError(
-        std::make_error_code(std::errc::bad_message),
+        std::make_error_code(std::errc::invalid_argument),
         "Failed reading data into buffer of size %d at offset %d.", R.Size,
         OffsetPtr);
   R.Data.assign(Buffer.begin(), Buffer.end());
   return Error::success();
 }
 
 Error RecordInitializer::visit(CallArgRecord &R) {
   if (!E.isValidOffsetForDataOfSize(OffsetPtr,
                                     MetadataRecord::kMetadataBodySize))
     return createStringError(std::make_error_code(std::errc::bad_address),
                              "Invalid offset for a call argument record (%d).",
                              OffsetPtr);
 
   auto PreReadOffset = OffsetPtr;
   R.Arg = E.getU64(&OffsetPtr);
   if (PreReadOffset == OffsetPtr)
-    return createStringError(std::make_error_code(std::errc::bad_message),
+    return createStringError(std::make_error_code(std::errc::invalid_argument),
                              "Cannot read a call arg record at offset %d.",
                              OffsetPtr);
 
   OffsetPtr += MetadataRecord::kMetadataBodySize - (OffsetPtr - PreReadOffset);
   return Error::success();
 }
 
 Error RecordInitializer::visit(PIDRecord &R) {
   if (!E.isValidOffsetForDataOfSize(OffsetPtr,
                                     MetadataRecord::kMetadataBodySize))
     return createStringError(std::make_error_code(std::errc::bad_address),
                              "Invalid offset for a process ID record (%d).",
                              OffsetPtr);
 
   auto PreReadOffset = OffsetPtr;
   R.PID = E.getSigned(&OffsetPtr, 4);
   if (PreReadOffset == OffsetPtr)
-    return createStringError(std::make_error_code(std::errc::bad_message),
+    return createStringError(std::make_error_code(std::errc::invalid_argument),
                              "Cannot read a process ID record at offset %d.",
                              OffsetPtr);
 
   OffsetPtr += MetadataRecord::kMetadataBodySize - (OffsetPtr - PreReadOffset);
   return Error::success();
 }
 
 Error RecordInitializer::visit(NewBufferRecord &R) {
   if (!E.isValidOffsetForDataOfSize(OffsetPtr,
                                     MetadataRecord::kMetadataBodySize))
     return createStringError(std::make_error_code(std::errc::bad_address),
                              "Invalid offset for a new buffer record (%d).",
                              OffsetPtr);
 
   auto PreReadOffset = OffsetPtr;
   R.TID = E.getSigned(&OffsetPtr, sizeof(int32_t));
   if (PreReadOffset == OffsetPtr)
-    return createStringError(std::make_error_code(std::errc::bad_message),
+    return createStringError(std::make_error_code(std::errc::invalid_argument),
                              "Cannot read a new buffer record at offset %d.",
                              OffsetPtr);
 
   OffsetPtr += MetadataRecord::kMetadataBodySize - (OffsetPtr - PreReadOffset);
   return Error::success();
 }
 
 Error RecordInitializer::visit(EndBufferRecord &R) {
Error RecordInitializer::visit(FunctionRecord &R) {
   switch (FunctionType) {
   case static_cast<unsigned>(RecordTypes::ENTER):
   case static_cast<unsigned>(RecordTypes::ENTER_ARG):
   case static_cast<unsigned>(RecordTypes::EXIT):
   case static_cast<unsigned>(RecordTypes::TAIL_EXIT):
     R.Kind = static_cast<RecordTypes>(FunctionType);
     break;
   default:
-    return createStringError(std::make_error_code(std::errc::bad_message),
+    return createStringError(std::make_error_code(std::errc::invalid_argument),
                              "Unknown function record type '%d' at offset %d.",
                              FunctionType, BeginOffset);
   }
 
   R.FuncId = Buffer >> 4;
   PreReadOffset = OffsetPtr;
   R.Delta = E.getU32(&OffsetPtr);
   if (OffsetPtr == PreReadOffset)
-    return createStringError(std::make_error_code(std::errc::bad_message),
+    return createStringError(std::make_error_code(std::errc::invalid_argument),
                              "Failed reading TSC delta from offset %d.",
                              OffsetPtr);
   assert(FunctionRecord::kFunctionRecordSize == (OffsetPtr - BeginOffset));
   return Error::success();
 }
 
 } // namespace xray
 } // namespace llvm