Add Clang compatibility and fix remaining Clang-specific warnings

maxwbuckley · claude · maxwbuckley · commit 1450598f84c9 · 2026-03-22T19:54:26.000+01:00
- Add Clang-specific suppression for -Wvariadic-macro-arguments-omitted
  (triggered by CUDA toolkit headers) and -Wsign-conversion (not part
  of GCC's -Wconversion)
- Fix deprecated literal operator syntax (remove space before _GiB etc.)
- Fix Clang -Wdouble-promotion: use lroundf() instead of lround() for
  float args, explicit casts for long double expressions
- Fix Clang -Wfloat-conversion: use explicit != 0.0F instead of
  implicit float-to-bool
- Fix Clang -Wsign-conversion: add static_cast&lt;size_t&gt;() for int-to-
  size_t conversions in sample code

Co-Authored-By: Claude Opus 4.6 (1M context) &lt;noreply@anthropic.com&gt;
diff --git a/CMakeLists.txt b/CMakeLists.txt
@@ -264,6 +264,14 @@ if(NOT MSVC)
     set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -Wformat=2 -Wimplicit-fallthrough")
     set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -Wno-deprecated-declarations")
     set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -Werror")
+
+    # Clang-specific suppressions
+    if(CMAKE_CXX_COMPILER_ID STREQUAL "Clang")
+        # CUDA toolkit headers trigger variadic macro warnings
+        set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -Wno-variadic-macro-arguments-omitted")
+        # Clang's -Wpedantic enables -Wsign-conversion (GCC does not)
+        set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -Wno-sign-conversion")
+    endif()
 else()
     set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -DBUILD_SYSTEM=cmake_oss")
     set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} /W4 /WX")
diff --git a/plugin/groupNormalizationPlugin/groupNormalizationPlugin.cpp b/plugin/groupNormalizationPlugin/groupNormalizationPlugin.cpp
@@ -159,7 +159,7 @@ int32_t GroupNormalizationPlugin::enqueue(nvinfer1::PluginTensorDesc const* inpu
         mBNTensorDesc,                 //
         mBnScales->mPtr,               // 1
         mBnBias->mPtr,                 // 0
-        0.0F,                          // exponential average factor
+        static_cast<double>(0.0F),     // exponential average factor
         nullptr,                       // resultRunningMean
         nullptr,                       // resultRunningVar
         static_cast<double>(mEpsilon), //  eps
diff --git a/plugin/voxelGeneratorPlugin/voxelGenerator.cpp b/plugin/voxelGeneratorPlugin/voxelGenerator.cpp
@@ -39,12 +39,12 @@ size_t constexpr kSERIALIZATION_SIZE{9 * sizeof(float) + 7 * sizeof(int32_t)};
 int32_t npRound(float x)
 {
     // half way round to nearest-even
-    int32_t x2 = static_cast<int32_t>(lround(x * 2.0F));
+    int32_t x2 = static_cast<int32_t>(lroundf(x * 2.0F));
     if (x != static_cast<float>(static_cast<int32_t>(x)) && static_cast<float>(x2) == x * 2.0F)
     {
-        return static_cast<int32_t>(lround(x / 2.0F + 0.5F)) * 2;
+        return static_cast<int32_t>(lroundf(x / 2.0F + 0.5F)) * 2;
     }
-    return static_cast<int32_t>(lround(x));
+    return static_cast<int32_t>(lroundf(x));
 }
 
 VoxelGeneratorPlugin::VoxelGeneratorPlugin(int32_t maxVoxels, int32_t maxPoints, int32_t voxelFeatures, float xMin,
diff --git a/samples/common/ErrorRecorder.h b/samples/common/ErrorRecorder.h
@@ -52,11 +52,13 @@ class SampleErrorRecorder : public IErrorRecorder
     }
     ErrorCode getErrorCode(int32_t errorIdx) const noexcept final
     {
-        return invalidIndexCheck(errorIdx) ? ErrorCode::kINVALID_ARGUMENT : (*this)[errorIdx].first;
+        return invalidIndexCheck(errorIdx) ? ErrorCode::kINVALID_ARGUMENT
+                                           : (*this)[static_cast<size_t>(errorIdx)].first;
     };
     IErrorRecorder::ErrorDesc getErrorDesc(int32_t errorIdx) const noexcept final
     {
-        return invalidIndexCheck(errorIdx) ? "errorIdx out of range." : (*this)[errorIdx].second.c_str();
+        return invalidIndexCheck(errorIdx) ? "errorIdx out of range."
+                                           : (*this)[static_cast<size_t>(errorIdx)].second.c_str();
     }
     // This class can never overflow since we have dynamic resize via std::vector usage.
     bool hasOverflowed() const noexcept final
@@ -122,7 +124,7 @@ class SampleErrorRecorder : public IErrorRecorder
     {
         // By converting signed to unsigned, we only need a single check since
         // negative numbers turn into large positive greater than the size.
-        size_t sIndex = index;
+        size_t sIndex = static_cast<size_t>(index);
         return sIndex >= mErrorStack.size();
     }
     // Mutex to hold when locking mErrorStack.
diff --git a/samples/common/common.h b/samples/common/common.h
@@ -105,15 +105,15 @@ using namespace nvinfer1;
 #undef CHECK
 #define CHECK(status) CHECK_WITH_STREAM(status, std::cerr)
 
-constexpr long double operator"" _GiB(long double val)
+constexpr long double operator""_GiB(long double val)
 {
     return val * (1 << 30);
 }
-constexpr long double operator"" _MiB(long double val)
+constexpr long double operator""_MiB(long double val)
 {
     return val * (1 << 20);
 }
-constexpr long double operator"" _KiB(long double val)
+constexpr long double operator""_KiB(long double val)
 {
     return val * (1 << 10);
 }
@@ -536,28 +536,28 @@ inline size_t getNbBytes(nvinfer1::DataType t, int64_t vol) noexcept
 {
     switch (t)
     {
-    case nvinfer1::DataType::kINT64: return 8 * vol;
+    case nvinfer1::DataType::kINT64: return static_cast<size_t>(8 * vol);
     case nvinfer1::DataType::kINT32:
-    case nvinfer1::DataType::kFLOAT: return 4 * vol;
+    case nvinfer1::DataType::kFLOAT: return static_cast<size_t>(4 * vol);
     case nvinfer1::DataType::kBF16:
-    case nvinfer1::DataType::kHALF: return 2 * vol;
+    case nvinfer1::DataType::kHALF: return static_cast<size_t>(2 * vol);
     case nvinfer1::DataType::kBOOL:
     case nvinfer1::DataType::kUINT8:
-    case nvinfer1::DataType::kINT8: return vol;
+    case nvinfer1::DataType::kINT8: return static_cast<size_t>(vol);
     case nvinfer1::DataType::kFP8:
 #if CUDA_VERSION < 11060
         ASSERT(false && "FP8 is not supported");
 #else
-        return vol;
+        return static_cast<size_t>(vol);
 #endif
     case nvinfer1::DataType::kE8M0:
 #if CUDA_VERSION < 12080
         ASSERT(false && "E8M0 is not supported");
 #else
-        return vol;
+        return static_cast<size_t>(vol);
 #endif // CUDA_VERSION < 12080
     case nvinfer1::DataType::kINT4:
-    case nvinfer1::DataType::kFP4: return (vol + 1) / 2;
+    case nvinfer1::DataType::kFP4: return static_cast<size_t>((vol + 1) / 2);
     }
     ASSERT(false && "Unknown element type");
 }
@@ -759,25 +759,25 @@ inline void writePPMFileWithBBox(const std::string& filename, vPPM ppm, std::vec
         for (int x = int(bbox.x1); x < int(bbox.x2); ++x)
         {
             // bbox top border
-            ppm.buffer[(round(bbox.y1) * ppm.w + x) * 3] = 255;
-            ppm.buffer[(round(bbox.y1) * ppm.w + x) * 3 + 1] = 0;
-            ppm.buffer[(round(bbox.y1) * ppm.w + x) * 3 + 2] = 0;
+            ppm.buffer[static_cast<size_t>((round(bbox.y1) * ppm.w + x) * 3)] = 255;
+            ppm.buffer[static_cast<size_t>((round(bbox.y1) * ppm.w + x) * 3 + 1)] = 0;
+            ppm.buffer[static_cast<size_t>((round(bbox.y1) * ppm.w + x) * 3 + 2)] = 0;
             // bbox bottom border
-            ppm.buffer[(round(bbox.y2) * ppm.w + x) * 3] = 255;
-            ppm.buffer[(round(bbox.y2) * ppm.w + x) * 3 + 1] = 0;
-            ppm.buffer[(round(bbox.y2) * ppm.w + x) * 3 + 2] = 0;
+            ppm.buffer[static_cast<size_t>((round(bbox.y2) * ppm.w + x) * 3)] = 255;
+            ppm.buffer[static_cast<size_t>((round(bbox.y2) * ppm.w + x) * 3 + 1)] = 0;
+            ppm.buffer[static_cast<size_t>((round(bbox.y2) * ppm.w + x) * 3 + 2)] = 0;
         }
 
         for (int y = int(bbox.y1); y < int(bbox.y2); ++y)
         {
             // bbox left border
-            ppm.buffer[(y * ppm.w + round(bbox.x1)) * 3] = 255;
-            ppm.buffer[(y * ppm.w + round(bbox.x1)) * 3 + 1] = 0;
-            ppm.buffer[(y * ppm.w + round(bbox.x1)) * 3 + 2] = 0;
+            ppm.buffer[static_cast<size_t>((y * ppm.w + round(bbox.x1)) * 3)] = 255;
+            ppm.buffer[static_cast<size_t>((y * ppm.w + round(bbox.x1)) * 3 + 1)] = 0;
+            ppm.buffer[static_cast<size_t>((y * ppm.w + round(bbox.x1)) * 3 + 2)] = 0;
             // bbox right border
-            ppm.buffer[(y * ppm.w + round(bbox.x2)) * 3] = 255;
-            ppm.buffer[(y * ppm.w + round(bbox.x2)) * 3 + 1] = 0;
-            ppm.buffer[(y * ppm.w + round(bbox.x2)) * 3 + 2] = 0;
+            ppm.buffer[static_cast<size_t>((y * ppm.w + round(bbox.x2)) * 3)] = 255;
+            ppm.buffer[static_cast<size_t>((y * ppm.w + round(bbox.x2)) * 3 + 1)] = 0;
+            ppm.buffer[static_cast<size_t>((y * ppm.w + round(bbox.x2)) * 3 + 2)] = 0;
         }
     }
 
diff --git a/samples/common/getOptions.cpp b/samples/common/getOptions.cpp
@@ -201,12 +201,13 @@ TRTParsedArgs parseArgs(int argc, const char* const* argv, const std::vector<TRT
             continue;
         }
 
-        if (options[idx].valueRequired)
+        if (options[static_cast<size_t>(idx)].valueRequired)
         {
             if (!value.empty())
             {
-                parsedArgs.values[idx].second.push_back(value);
-                parsedArgs.values[idx].first = static_cast<int>(parsedArgs.values[idx].second.size());
+                parsedArgs.values[static_cast<size_t>(idx)].second.push_back(value);
+                parsedArgs.values[static_cast<size_t>(idx)].first
+                    = static_cast<int>(parsedArgs.values[static_cast<size_t>(idx)].second.size());
                 continue;
             }
 
@@ -222,14 +223,15 @@ TRTParsedArgs parseArgs(int argc, const char* const* argv, const std::vector<TRT
                                     << "', Should this be its own flag?" << std::endl;
             }
 
-            parsedArgs.values[idx].second.push_back(nextArg);
+            parsedArgs.values[static_cast<size_t>(idx)].second.push_back(nextArg);
             i += 1; // Next argument already consumed
 
-            parsedArgs.values[idx].first = static_cast<int>(parsedArgs.values[idx].second.size());
+            parsedArgs.values[static_cast<size_t>(idx)].first
+                = static_cast<int>(parsedArgs.values[static_cast<size_t>(idx)].second.size());
         }
         else
         {
-            parsedArgs.values[idx].first += 1;
+            parsedArgs.values[static_cast<size_t>(idx)].first += 1;
         }
     }
     return parsedArgs;
diff --git a/samples/common/sampleInference.cpp b/samples/common/sampleInference.cpp
@@ -1426,7 +1426,7 @@ bool inferenceLoop(std::vector<std::unique_ptr<IterationBase>>& iStreams, TimePo
         }
         if (durationMs < warmupMs) // Warming up
         {
-            if (durationMs) // Skip complete iterations
+            if (durationMs != 0.0F) // Skip complete iterations
             {
                 ++skip;
             }
diff --git a/samples/common/sampleOptions.cpp b/samples/common/sampleOptions.cpp
@@ -1189,27 +1189,27 @@ void BuildOptions::parse(Arguments& arguments)
         if (memPoolName == "workspace")
         {
             // use unit in MB.
-            workspace = static_cast<double>(memPoolSize / 1.0_MiB);
+            workspace = static_cast<double>(static_cast<long double>(memPoolSize) / 1.0_MiB);
         }
         else if (memPoolName == "dlaSRAM")
         {
             // use unit in MB.
-            dlaSRAM = static_cast<double>(memPoolSize / 1.0_MiB);
+            dlaSRAM = static_cast<double>(static_cast<long double>(memPoolSize) / 1.0_MiB);
         }
         else if (memPoolName == "dlaLocalDRAM")
         {
             // use unit in MB.
-            dlaLocalDRAM = static_cast<double>(memPoolSize / 1.0_MiB);
+            dlaLocalDRAM = static_cast<double>(static_cast<long double>(memPoolSize) / 1.0_MiB);
         }
         else if (memPoolName == "dlaGlobalDRAM")
         {
             // use unit in MB.
-            dlaGlobalDRAM = static_cast<double>(memPoolSize / 1.0_MiB);
+            dlaGlobalDRAM = static_cast<double>(static_cast<long double>(memPoolSize) / 1.0_MiB);
         }
         else if (memPoolName == "tacticSharedMem")
         {
             // use unit in KB.
-            tacticSharedMem = static_cast<double>(memPoolSize / 1.0_KiB);
+            tacticSharedMem = static_cast<double>(static_cast<long double>(memPoolSize) / 1.0_KiB);
         }
         else if (!memPoolName.empty())
         {

Original file line number	Diff line number	Diff line change
`@@ -39,12 +39,12 @@ size_t constexpr kSERIALIZATION_SIZE{9 * sizeof(float) + 7 * sizeof(int32_t)};`
`39`	`39`	`int32_t npRound(float x)`
`40`	`40`	`{`
`41`	`41`	`// half way round to nearest-even`
`42`		`- int32_t x2 = static_cast<int32_t>(lround(x * 2.0F));`
	`42`	`+ int32_t x2 = static_cast<int32_t>(lroundf(x * 2.0F));`
`43`	`43`	`if (x != static_cast<float>(static_cast<int32_t>(x)) && static_cast<float>(x2) == x * 2.0F)`
`44`	`44`	`{`
`45`		`- return static_cast<int32_t>(lround(x / 2.0F + 0.5F)) * 2;`
	`45`	`+ return static_cast<int32_t>(lroundf(x / 2.0F + 0.5F)) * 2;`
`46`	`46`	`}`
`47`		`- return static_cast<int32_t>(lround(x));`
	`47`	`+ return static_cast<int32_t>(lroundf(x));`
`48`	`48`	`}`
`49`	`49`
`50`	`50`	`VoxelGeneratorPlugin::VoxelGeneratorPlugin(int32_t maxVoxels, int32_t maxPoints, int32_t voxelFeatures, float xMin,`
Original file line number	Diff line number	Diff line change
`@@ -52,11 +52,13 @@ class SampleErrorRecorder : public IErrorRecorder`
`52`	`52`	`}`
`53`	`53`	`ErrorCode getErrorCode(int32_t errorIdx) const noexcept final`
`54`	`54`	`{`
`55`		`- return invalidIndexCheck(errorIdx) ? ErrorCode::kINVALID_ARGUMENT : (*this)[errorIdx].first;`
	`55`	`+ return invalidIndexCheck(errorIdx) ? ErrorCode::kINVALID_ARGUMENT`
	`56`	`+ : (*this)[static_cast<size_t>(errorIdx)].first;`
`56`	`57`	`};`
`57`	`58`	`IErrorRecorder::ErrorDesc getErrorDesc(int32_t errorIdx) const noexcept final`
`58`	`59`	`{`
`59`		`- return invalidIndexCheck(errorIdx) ? "errorIdx out of range." : (*this)[errorIdx].second.c_str();`
	`60`	`+ return invalidIndexCheck(errorIdx) ? "errorIdx out of range."`
	`61`	`+ : (*this)[static_cast<size_t>(errorIdx)].second.c_str();`
`60`	`62`	`}`
`61`	`63`	`// This class can never overflow since we have dynamic resize via std::vector usage.`
`62`	`64`	`bool hasOverflowed() const noexcept final`
`@@ -122,7 +124,7 @@ class SampleErrorRecorder : public IErrorRecorder`
`122`	`124`	`{`
`123`	`125`	`// By converting signed to unsigned, we only need a single check since`
`124`	`126`	`// negative numbers turn into large positive greater than the size.`
`125`		`- size_t sIndex = index;`
	`127`	`+ size_t sIndex = static_cast<size_t>(index);`
`126`	`128`	`return sIndex >= mErrorStack.size();`
`127`	`129`	`}`
`128`	`130`	`// Mutex to hold when locking mErrorStack.`
Original file line number	Diff line number	Diff line change
`@@ -201,12 +201,13 @@ TRTParsedArgs parseArgs(int argc, const char* const* argv, const std::vector<TRT`
`201`	`201`	`continue;`
`202`	`202`	`}`
`203`	`203`
`204`		`- if (options[idx].valueRequired)`
	`204`	`+ if (options[static_cast<size_t>(idx)].valueRequired)`
`205`	`205`	`{`
`206`	`206`	`if (!value.empty())`
`207`	`207`	`{`
`208`		`- parsedArgs.values[idx].second.push_back(value);`
`209`		`- parsedArgs.values[idx].first = static_cast<int>(parsedArgs.values[idx].second.size());`
	`208`	`+ parsedArgs.values[static_cast<size_t>(idx)].second.push_back(value);`
	`209`	`+ parsedArgs.values[static_cast<size_t>(idx)].first`
	`210`	`+ = static_cast<int>(parsedArgs.values[static_cast<size_t>(idx)].second.size());`
`210`	`211`	`continue;`
`211`	`212`	`}`
`212`	`213`
`@@ -222,14 +223,15 @@ TRTParsedArgs parseArgs(int argc, const char* const* argv, const std::vector<TRT`
`222`	`223`	`<< "', Should this be its own flag?" << std::endl;`
`223`	`224`	`}`
`224`	`225`
`225`		`- parsedArgs.values[idx].second.push_back(nextArg);`
	`226`	`+ parsedArgs.values[static_cast<size_t>(idx)].second.push_back(nextArg);`
`226`	`227`	`i += 1; // Next argument already consumed`
`227`	`228`
`228`		`- parsedArgs.values[idx].first = static_cast<int>(parsedArgs.values[idx].second.size());`
	`229`	`+ parsedArgs.values[static_cast<size_t>(idx)].first`
	`230`	`+ = static_cast<int>(parsedArgs.values[static_cast<size_t>(idx)].second.size());`
`229`	`231`	`}`
`230`	`232`	`else`
`231`	`233`	`{`
`232`		`- parsedArgs.values[idx].first += 1;`
	`234`	`+ parsedArgs.values[static_cast<size_t>(idx)].first += 1;`
`233`	`235`	`}`
`234`	`236`	`}`
`235`	`237`	`return parsedArgs;`
Original file line number	Diff line number	Diff line change
`@@ -1426,7 +1426,7 @@ bool inferenceLoop(std::vector<std::unique_ptr<IterationBase>>& iStreams, TimePo`
`1426`	`1426`	`}`
`1427`	`1427`	`if (durationMs < warmupMs) // Warming up`
`1428`	`1428`	`{`
`1429`		`- if (durationMs) // Skip complete iterations`
	`1429`	`+ if (durationMs != 0.0F) // Skip complete iterations`
`1430`	`1430`	`{`
`1431`	`1431`	`++skip;`
`1432`	`1432`	`}`
Original file line number	Diff line number	Diff line change
`@@ -1189,27 +1189,27 @@ void BuildOptions::parse(Arguments& arguments)`
`1189`	`1189`	`if (memPoolName == "workspace")`
`1190`	`1190`	`{`
`1191`	`1191`	`// use unit in MB.`
`1192`		`- workspace = static_cast<double>(memPoolSize / 1.0_MiB);`
	`1192`	`+ workspace = static_cast<double>(static_cast<long double>(memPoolSize) / 1.0_MiB);`
`1193`	`1193`	`}`
`1194`	`1194`	`else if (memPoolName == "dlaSRAM")`
`1195`	`1195`	`{`
`1196`	`1196`	`// use unit in MB.`
`1197`		`- dlaSRAM = static_cast<double>(memPoolSize / 1.0_MiB);`
	`1197`	`+ dlaSRAM = static_cast<double>(static_cast<long double>(memPoolSize) / 1.0_MiB);`
`1198`	`1198`	`}`
`1199`	`1199`	`else if (memPoolName == "dlaLocalDRAM")`
`1200`	`1200`	`{`
`1201`	`1201`	`// use unit in MB.`
`1202`		`- dlaLocalDRAM = static_cast<double>(memPoolSize / 1.0_MiB);`
	`1202`	`+ dlaLocalDRAM = static_cast<double>(static_cast<long double>(memPoolSize) / 1.0_MiB);`
`1203`	`1203`	`}`
`1204`	`1204`	`else if (memPoolName == "dlaGlobalDRAM")`
`1205`	`1205`	`{`
`1206`	`1206`	`// use unit in MB.`
`1207`		`- dlaGlobalDRAM = static_cast<double>(memPoolSize / 1.0_MiB);`
	`1207`	`+ dlaGlobalDRAM = static_cast<double>(static_cast<long double>(memPoolSize) / 1.0_MiB);`
`1208`	`1208`	`}`
`1209`	`1209`	`else if (memPoolName == "tacticSharedMem")`
`1210`	`1210`	`{`
`1211`	`1211`	`// use unit in KB.`
`1212`		`- tacticSharedMem = static_cast<double>(memPoolSize / 1.0_KiB);`
	`1212`	`+ tacticSharedMem = static_cast<double>(static_cast<long double>(memPoolSize) / 1.0_KiB);`
`1213`	`1213`	`}`
`1214`	`1214`	`else if (!memPoolName.empty())`
`1215`	`1215`	`{`