From f7f6bb082809400d1e4d2b420993124ead6c2fe2 Mon Sep 17 00:00:00 2001 From: Robin Kuzmin Date: Fri, 11 Jun 2021 16:29:09 -0700 Subject: [PATCH 1/8] Added -Wall --- src/Qir/qir-utils.ps1 | 45 +++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 45 insertions(+) diff --git a/src/Qir/qir-utils.ps1 b/src/Qir/qir-utils.ps1 index d5b577a26e3..1d06dc5df73 100644 --- a/src/Qir/qir-utils.ps1 +++ b/src/Qir/qir-utils.ps1 @@ -40,7 +40,52 @@ function Build-CMakeProject { $clangTidy = "" + # -Wall + # -Wmisleading-indentation, + # -Wmost, + # -Wcast-of-sel-type, + # -Wchar-subscripts, + # -Wcomment, + # -Wdelete-non-virtual-dtor, + # -Wextern-c-compat, + # -Wfor-loop-analysis, + # -Wformat, + # -Wframe-address, + # -Wimplicit, + # -Winfinite-recursion, + # -Wint-in-bool-context, + # -Wmismatched-tags, + # -Wmissing-braces, + # -Wmove, + # -Wmultichar, + # -Wobjc-designated-initializers, + # -Wobjc-flexible-array, + # -Wobjc-missing-super-calls, + # -Woverloaded-virtual, + # -Wprivate-extern, + # -Wrange-loop-construct, + # -Wreorder, + # -Wreturn-type, + # -Wself-assign, + # -Wself-move, + # -Wsizeof-array-argument, + # -Wsizeof-array-decay, + # -Wstring-plus-int, + # -Wtautological-compare, + # -Wtrigraphs, + # -Wuninitialized, + # -Wunknown-pragmas, + # -Wunused, + # -Wuser-defined-warnings, + # -Wvolatile-register-var. + # -Wparentheses, + # -Wswitch, + # -Wswitch-bool. $warningFlags = "-Werror" + + # https://clang.llvm.org/docs/DiagnosticsReference.html#wall + $warningFlags += "-Wall" + $env:CFLAGS += $warningFlags $env:CXXFLAGS += $warningFlags From 1b54661c9357cf79a2b4b89677a7ea1add50e7f0 Mon Sep 17 00:00:00 2001 From: Robin Kuzmin Date: Fri, 11 Jun 2021 16:47:50 -0700 Subject: [PATCH 2/8] Excluded unused --- src/Qir/qir-utils.ps1 | 8 +++++--- 1 file changed, 5 insertions(+), 3 deletions(-) diff --git a/src/Qir/qir-utils.ps1 b/src/Qir/qir-utils.ps1 index 1d06dc5df73..c0742679b5d 100644 --- a/src/Qir/qir-utils.ps1 +++ b/src/Qir/qir-utils.ps1 @@ -40,6 +40,8 @@ function Build-CMakeProject { $clangTidy = "" + $warningFlags = "-Werror" + # -Wall # -Wmisleading-indentation, # -Wmost, @@ -81,10 +83,10 @@ function Build-CMakeProject { # -Wparentheses, # -Wswitch, # -Wswitch-bool. - $warningFlags = "-Werror" - # https://clang.llvm.org/docs/DiagnosticsReference.html#wall - $warningFlags += "-Wall" + $warningFlags += " -Wall" + + $warningFlags += " -Wno-error=unused" # Treat unused entities as warningns rather than errors. https://clang.llvm.org/docs/DiagnosticsReference.html#wunused $env:CFLAGS += $warningFlags $env:CXXFLAGS += $warningFlags From 5b60aa3d7a9a5ae435600b2b543db682356edb91 Mon Sep 17 00:00:00 2001 From: Robin Kuzmin Date: Fri, 11 Jun 2021 18:25:32 -0700 Subject: [PATCH 3/8] Added -Wextra --- src/Qir/Common/Include/SimulatorStub.hpp | 62 +++++++++---------- src/Qir/Runtime/lib/QIR/QubitManager.cpp | 2 +- src/Qir/Runtime/lib/QIR/arrays.cpp | 2 +- .../QSharpFoundation/AssertMeasurement.cpp | 2 +- .../lib/Simulators/FullstateSimulator.cpp | 22 +++---- .../lib/Simulators/ToffoliSimulator.cpp | 60 +++++++++--------- src/Qir/Runtime/lib/Tracer/tracer-qis.cpp | 6 +- src/Qir/Runtime/lib/Tracer/tracer.cpp | 8 +-- src/Qir/Runtime/lib/Tracer/tracer.hpp | 4 +- src/Qir/Runtime/unittests/QirRuntimeTests.cpp | 4 +- src/Qir/qir-utils.ps1 | 57 ++++++----------- 11 files changed, 105 insertions(+), 124 deletions(-) diff --git a/src/Qir/Common/Include/SimulatorStub.hpp b/src/Qir/Common/Include/SimulatorStub.hpp index 5a2a2459e9f..1c226ad6824 100644 --- a/src/Qir/Common/Include/SimulatorStub.hpp +++ b/src/Qir/Common/Include/SimulatorStub.hpp @@ -15,113 +15,113 @@ namespace Quantum { throw std::logic_error("not_implemented: AllocateQubit"); } - void ReleaseQubit(Qubit qubit) override + void ReleaseQubit(Qubit /* qubit */) override { throw std::logic_error("not_implemented: ReleaseQubit"); } - virtual std::string QubitToString(Qubit qubit) override + virtual std::string QubitToString(Qubit /* qubit */) override { throw std::logic_error("not_implemented: QubitToString"); } - void X(Qubit target) override + void X(Qubit /*target*/) override { throw std::logic_error("not_implemented: X"); } - void Y(Qubit target) override + void Y(Qubit /*target*/) override { throw std::logic_error("not_implemented: Y"); } - void Z(Qubit target) override + void Z(Qubit /* target */) override { throw std::logic_error("not_implemented: Z"); } - void H(Qubit target) override + void H(Qubit /*target*/) override { throw std::logic_error("not_implemented: H"); } - void S(Qubit target) override + void S(Qubit /*target*/) override { throw std::logic_error("not_implemented: S"); } - void T(Qubit target) override + void T(Qubit /*target*/) override { throw std::logic_error("not_implemented: T"); } - void R(PauliId axis, Qubit target, double theta) override + void R(PauliId /* axis */, Qubit /* target */, double /* theta */) override { throw std::logic_error("not_implemented: R"); } - void Exp(long numTargets, PauliId paulis[], Qubit targets[], double theta) override + void Exp(long /* numTargets */, PauliId* /* paulis */, Qubit* /* targets */, double /* theta */) override { throw std::logic_error("not_implemented: Exp"); } - void ControlledX(long numControls, Qubit controls[], Qubit target) override + void ControlledX(long /*numControls*/, Qubit* /*controls*/, Qubit /*target*/) override { throw std::logic_error("not_implemented: ControlledX"); } - void ControlledY(long numControls, Qubit controls[], Qubit target) override + void ControlledY(long /*numControls*/, Qubit* /*controls*/, Qubit /*target*/) override { throw std::logic_error("not_implemented: ControlledY"); } - void ControlledZ(long numControls, Qubit controls[], Qubit target) override + void ControlledZ(long /*numControls*/, Qubit* /*controls*/, Qubit /*target*/) override { throw std::logic_error("not_implemented: ControlledZ"); } - void ControlledH(long numControls, Qubit controls[], Qubit target) override + void ControlledH(long /*numControls*/, Qubit* /*controls*/, Qubit /*target*/) override { throw std::logic_error("not_implemented: ControlledH"); } - void ControlledS(long numControls, Qubit controls[], Qubit target) override + void ControlledS(long /*numControls*/, Qubit* /*controls*/, Qubit /*target*/) override { throw std::logic_error("not_implemented: ControlledS"); } - void ControlledT(long numControls, Qubit controls[], Qubit target) override + void ControlledT(long /*numControls*/, Qubit* /*controls*/, Qubit /*target*/) override { throw std::logic_error("not_implemented: ControlledT"); } - void ControlledR(long numControls, Qubit controls[], PauliId axis, Qubit target, double theta) override + void ControlledR(long /*numControls*/, Qubit* /*controls*/, PauliId /*axis*/, Qubit /*target*/, double /*theta*/) override { throw std::logic_error("not_implemented: ControlledR"); } void ControlledExp( - long numControls, - Qubit controls[], - long numTargets, - PauliId paulis[], - Qubit targets[], - double theta) override + long /*numControls*/, + Qubit* /*controls*/, + long /*numTargets*/, + PauliId* /*paulis*/, + Qubit* /*targets*/, + double /*theta*/) override { throw std::logic_error("not_implemented: ControlledExp"); } - void AdjointS(Qubit target) override + void AdjointS(Qubit) override { throw std::logic_error("not_implemented: AdjointS"); } - void AdjointT(Qubit target) override + void AdjointT(Qubit /*target*/) override { throw std::logic_error("not_implemented: AdjointT"); } - void ControlledAdjointS(long numControls, Qubit controls[], Qubit target) override + void ControlledAdjointS(long /*numControls*/, Qubit* /*controls*/, Qubit /*target*/) override { throw std::logic_error("not_implemented: ControlledAdjointS"); } - void ControlledAdjointT(long numControls, Qubit controls[], Qubit target) override + void ControlledAdjointT(long /*numControls*/, Qubit* /*controls*/, Qubit /*target*/) override { throw std::logic_error("not_implemented: ControlledAdjointT"); } - Result Measure(long numBases, PauliId bases[], long numTargets, Qubit targets[]) override + Result Measure(long /*numBases*/, PauliId* /*bases*/, long /*numTargets*/, Qubit* /*targets*/) override { throw std::logic_error("not_implemented: Measure"); } - void ReleaseResult(Result result) override + void ReleaseResult(Result) override { throw std::logic_error("not_implemented: ReleaseResult"); } - bool AreEqualResults(Result r1, Result r2) override + bool AreEqualResults(Result, Result) override { throw std::logic_error("not_implemented: AreEqualResults"); } - ResultValue GetResultValue(Result result) override + ResultValue GetResultValue(Result) override { throw std::logic_error("not_implemented: GetResultValue"); } diff --git a/src/Qir/Runtime/lib/QIR/QubitManager.cpp b/src/Qir/Runtime/lib/QIR/QubitManager.cpp index 0fed18c9d91..2a254ca349f 100644 --- a/src/Qir/Runtime/lib/QIR/QubitManager.cpp +++ b/src/Qir/Runtime/lib/QIR/QubitManager.cpp @@ -397,7 +397,7 @@ Qubit CQubitManager::CreateQubitObject(QubitIdType id) return reinterpret_cast(pointerSizedId); } -void CQubitManager::DeleteQubitObject(Qubit qubit) +void CQubitManager::DeleteQubitObject(Qubit /*qubit*/) { // Do nothing. By default we store qubit Id in place of a pointer to a qubit. } diff --git a/src/Qir/Runtime/lib/QIR/arrays.cpp b/src/Qir/Runtime/lib/QIR/arrays.cpp index 4c58691a3f3..fa8ff504b36 100644 --- a/src/Qir/Runtime/lib/QIR/arrays.cpp +++ b/src/Qir/Runtime/lib/QIR/arrays.cpp @@ -198,7 +198,7 @@ static int64_t GetLinearIndex(const std::vector& dimensionSizes, const // It's equal to the product of the dimension sizes in higher dimensions. static int64_t RunCount(const std::vector& dimensionSizes, int dimension) { - assert(dimension < dimensionSizes.size()); + assert((0 <= dimension) && ((size_t)dimension < dimensionSizes.size())); return std::accumulate(dimensionSizes.begin() + dimension + 1, dimensionSizes.end(), 1, std::multiplies()); } diff --git a/src/Qir/Runtime/lib/QSharpFoundation/AssertMeasurement.cpp b/src/Qir/Runtime/lib/QSharpFoundation/AssertMeasurement.cpp index 8f05e89ce2a..a18f85b17f9 100644 --- a/src/Qir/Runtime/lib/QSharpFoundation/AssertMeasurement.cpp +++ b/src/Qir/Runtime/lib/QSharpFoundation/AssertMeasurement.cpp @@ -36,7 +36,7 @@ extern "C" // Convert paulis from sequence of bytes to sequence of PauliId: std::vector paulis(bases->count); - for(size_t i = 0; i < bases->count; ++i) + for(int64_t i = 0; i < bases->count; ++i) { paulis[i] = (PauliId)(bases->buffer[i]); } diff --git a/src/Qir/Runtime/lib/Simulators/FullstateSimulator.cpp b/src/Qir/Runtime/lib/Simulators/FullstateSimulator.cpp index b6da62d9443..501cc734571 100644 --- a/src/Qir/Runtime/lib/Simulators/FullstateSimulator.cpp +++ b/src/Qir/Runtime/lib/Simulators/FullstateSimulator.cpp @@ -59,14 +59,14 @@ QUANTUM_SIMULATOR LoadQuantumSimulator() return handle; } -bool UnloadQuantumSimulator(QUANTUM_SIMULATOR handle) -{ -#ifdef _WIN32 - return ::FreeLibrary(handle); -#else // not _WIN32 - return ::dlclose(handle); -#endif -} +// bool UnloadQuantumSimulator(QUANTUM_SIMULATOR handle) +// { +// #ifdef _WIN32 +// return ::FreeLibrary(handle); +// #else // not _WIN32 +// return ::dlclose(handle); +// #endif +// } void* LoadProc(QUANTUM_SIMULATOR handle, const char* procName) { @@ -164,7 +164,7 @@ namespace Quantum } ~CFullstateSimulator() { - if (this->simulatorId != -1) + if (this->simulatorId != (unsigned)-1) { typedef unsigned (*TDestroy)(unsigned); static TDestroy destroySimulatorInstance = @@ -224,7 +224,7 @@ namespace Quantum m(this->simulatorId, numBases, reinterpret_cast(bases), ids.data())); } - void ReleaseResult(Result r) override {} + void ReleaseResult(Result) override {} ResultValue GetResultValue(Result r) override { @@ -408,7 +408,7 @@ namespace Quantum Qubit targets[], double probabilityOfZero, double precision, - const char* failureMessage) override + const char* /*failureMessage*/) override { typedef double (*TOp)(unsigned id, unsigned n, int* b, unsigned* q); static TOp jointEnsembleProbability = reinterpret_cast(this->GetProc("JointEnsembleProbability")); diff --git a/src/Qir/Runtime/lib/Simulators/ToffoliSimulator.cpp b/src/Qir/Runtime/lib/Simulators/ToffoliSimulator.cpp index f02742fcfd1..a26232fccf9 100644 --- a/src/Qir/Runtime/lib/Simulators/ToffoliSimulator.cpp +++ b/src/Qir/Runtime/lib/Simulators/ToffoliSimulator.cpp @@ -42,7 +42,7 @@ namespace Quantum /// /// Implementation of IRuntimeDriver /// - void ReleaseResult(Result result) override {} + void ReleaseResult(Result /* result */) override {} bool AreEqualResults(Result r1, Result r2) override { @@ -88,7 +88,7 @@ namespace Quantum /// /// Implementation of IDiagnostics /// - bool Assert(long numTargets, PauliId* bases, Qubit* targets, Result result, const char* failureMessage) override + bool Assert(long numTargets, PauliId* bases, Qubit* targets, Result result, const char* /* failureMessage */) override { // Measurements in Toffoli simulator don't change the state. // TODO: log failureMessage? @@ -101,7 +101,7 @@ namespace Quantum Qubit targets[], double probabilityOfZero, double precision, - const char* failureMessage) override + const char* /* failureMessage */) override { assert(precision >= 0); @@ -111,17 +111,17 @@ namespace Quantum } // Deprecated, use `DumpMachine()` and `DumpRegister()` instead. - void GetState(TGetStateCallback callback) override + void GetState(TGetStateCallback /* callback */) override { throw std::logic_error("operation_not_supported"); } - void DumpMachine(const void* location) override + void DumpMachine(const void* /* location */) override { std::cerr << __func__ << " is not yet implemented" << std::endl; // #645 } - void DumpRegister(const void* location, const QirArray* qubits) override + void DumpRegister(const void* /* location */, const QirArray* /* qubits */) override { std::cerr << __func__ << " is not yet implemented" << std::endl; // #645 } @@ -154,7 +154,7 @@ namespace Quantum } - Result Measure(long numBases, PauliId bases[], long numTargets, Qubit targets[]) override + Result Measure(long numBases, PauliId bases[], long /* numTargets */, Qubit targets[]) override { bool odd = false; for (long i = 0; i < numBases; i++) @@ -175,81 +175,81 @@ namespace Quantum // // The rest of the gate set Toffoli simulator doesn't support // - void Y(Qubit target) override + void Y(Qubit /*target*/) override { throw std::logic_error("operation_not_supported"); } - void Z(Qubit target) override + void Z(Qubit /*target*/) override { throw std::logic_error("operation_not_supported"); } - void H(Qubit target) override + void H(Qubit /*target*/) override { throw std::logic_error("operation_not_supported"); } - void S(Qubit target) override + void S(Qubit /*target*/) override { throw std::logic_error("operation_not_supported"); } - void T(Qubit target) override + void T(Qubit /*target*/) override { throw std::logic_error("operation_not_supported"); } - void R(PauliId axis, Qubit target, double theta) override + void R(PauliId /* axis */, Qubit /*target*/, double /* theta */) override { throw std::logic_error("operation_not_supported"); } - void Exp(long numTargets, PauliId paulis[], Qubit targets[], double theta) override + void Exp(long /* numTargets */, PauliId* /* paulis */, Qubit* /*targets*/, double /* theta */) override { throw std::logic_error("operation_not_supported"); } - void ControlledY(long numControls, Qubit controls[], Qubit target) override + void ControlledY(long /*numControls*/, Qubit* /*controls*/, Qubit /*target*/) override { throw std::logic_error("operation_not_supported"); } - void ControlledZ(long numControls, Qubit controls[], Qubit target) override + void ControlledZ(long /*numControls*/, Qubit* /*controls*/, Qubit /*target*/) override { throw std::logic_error("operation_not_supported"); } - void ControlledH(long numControls, Qubit controls[], Qubit target) override + void ControlledH(long /*numControls*/, Qubit* /*controls*/, Qubit /*target*/) override { throw std::logic_error("operation_not_supported"); } - void ControlledS(long numControls, Qubit controls[], Qubit target) override + void ControlledS(long /*numControls*/, Qubit* /*controls*/, Qubit /*target*/) override { throw std::logic_error("operation_not_supported"); } - void ControlledT(long numControls, Qubit controls[], Qubit target) override + void ControlledT(long /*numControls*/, Qubit* /*controls*/, Qubit /*target*/) override { throw std::logic_error("operation_not_supported"); } - void ControlledR(long numControls, Qubit controls[], PauliId axis, Qubit target, double theta) override + void ControlledR(long /*numControls*/, Qubit* /*controls*/, PauliId /*axis*/, Qubit /*target*/, double /*theta*/) override { throw std::logic_error("operation_not_supported"); } void ControlledExp( - long numControls, - Qubit controls[], - long numTargets, - PauliId paulis[], - Qubit targets[], - double theta) override + long /*numControls*/, + Qubit* /*controls*/, + long /*numTargets*/, + PauliId* /*paulis*/, + Qubit* /*targets*/, + double /* theta */) override { throw std::logic_error("operation_not_supported"); } - void AdjointS(Qubit target) override + void AdjointS(Qubit /*target*/) override { throw std::logic_error("operation_not_supported"); } - void AdjointT(Qubit target) override + void AdjointT(Qubit /*target*/) override { throw std::logic_error("operation_not_supported"); } - void ControlledAdjointS(long numControls, Qubit controls[], Qubit target) override + void ControlledAdjointS(long /*numControls*/, Qubit* /*controls*/, Qubit /*target*/) override { throw std::logic_error("operation_not_supported"); } - void ControlledAdjointT(long numControls, Qubit controls[], Qubit target) override + void ControlledAdjointT(long /*numControls*/, Qubit* /*controls*/, Qubit /*target*/) override { throw std::logic_error("operation_not_supported"); } diff --git a/src/Qir/Runtime/lib/Tracer/tracer-qis.cpp b/src/Qir/Runtime/lib/Tracer/tracer-qis.cpp index dd608602215..3bf363694d4 100644 --- a/src/Qir/Runtime/lib/Tracer/tracer-qis.cpp +++ b/src/Qir/Runtime/lib/Tracer/tracer-qis.cpp @@ -18,14 +18,14 @@ namespace Quantum using namespace Microsoft::Quantum; extern "C" { - void quantum__qis__on_operation_start(int64_t id) // NOLINT + void quantum__qis__on_operation_start(int64_t /* id */) // NOLINT { } - void quantum__qis__on_operation_end(int64_t id) // NOLINT + void quantum__qis__on_operation_end(int64_t /* id */) // NOLINT { } - void quantum__qis__swap(Qubit q1, Qubit q2) // NOLINT + void quantum__qis__swap(Qubit, Qubit) // NOLINT { } diff --git a/src/Qir/Runtime/lib/Tracer/tracer.cpp b/src/Qir/Runtime/lib/Tracer/tracer.cpp index c1cbe70f4bd..a4ccfbb0eae 100644 --- a/src/Qir/Runtime/lib/Tracer/tracer.cpp +++ b/src/Qir/Runtime/lib/Tracer/tracer.cpp @@ -116,7 +116,7 @@ namespace Quantum const LayerId barrier = this->GetEffectiveFence(); const LayerId firstLayerAfterBarrier = (barrier == INVALID ? (this->metricsByLayer.empty() ? REQUESTNEW : 0) - : ((barrier + 1 == this->metricsByLayer.size()) ? REQUESTNEW : barrier + 1)); + : (((size_t)(barrier + 1) == this->metricsByLayer.size()) ? REQUESTNEW : barrier + 1)); LayerId candidate = CTracer::LaterLayerOf(qstate.layer, firstLayerAfterBarrier); assert(candidate != INVALID); @@ -132,7 +132,7 @@ namespace Quantum } else { - for (candidate += 1; candidate < this->metricsByLayer.size(); ++candidate) + for (candidate += 1; (size_t)candidate < this->metricsByLayer.size(); ++candidate) { if (opDuration <= this->metricsByLayer[candidate].duration) { @@ -151,7 +151,7 @@ namespace Quantum //------------------------------------------------------------------------------------------------------------------ void CTracer::AddOperationToLayer(OpId id, LayerId layer) { - assert(layer < this->metricsByLayer.size()); + assert((size_t)layer < this->metricsByLayer.size()); assert(this->metricsByLayer[layer].barrierId == -1 && "Should not add operations to barriers"); this->metricsByLayer[layer].operations[id] += 1; @@ -319,7 +319,7 @@ namespace Quantum { return; } - assert(this->fence < this->tracer->metricsByLayer.size()); + assert((size_t)(this->fence) < this->tracer->metricsByLayer.size()); this->tracer->conditionalFences.push_back(this->fence); this->tracer->latestConditionalFence = CTracer::LaterLayerOf(this->tracer->latestConditionalFence, this->fence); diff --git a/src/Qir/Runtime/lib/Tracer/tracer.hpp b/src/Qir/Runtime/lib/Tracer/tracer.hpp index 35f242f1ecc..0d65110160e 100644 --- a/src/Qir/Runtime/lib/Tracer/tracer.hpp +++ b/src/Qir/Runtime/lib/Tracer/tracer.hpp @@ -148,11 +148,11 @@ namespace Quantum std::string QubitToString(Qubit qubit) override; void ReleaseResult(Result result) override; - bool AreEqualResults(Result r1, Result r2) override + bool AreEqualResults(Result, Result) override { throw std::logic_error("Cannot compare results while tracing!"); } - ResultValue GetResultValue(Result result) override + ResultValue GetResultValue(Result) override { throw std::logic_error("Result values aren't available while tracing!"); } diff --git a/src/Qir/Runtime/unittests/QirRuntimeTests.cpp b/src/Qir/Runtime/unittests/QirRuntimeTests.cpp index 66127fb69ae..e2be510ade7 100644 --- a/src/Qir/Runtime/unittests/QirRuntimeTests.cpp +++ b/src/Qir/Runtime/unittests/QirRuntimeTests.cpp @@ -768,7 +768,7 @@ struct ControlledCallablesTestSimulator : public SimulatorStub { return reinterpret_cast(++this->lastId); } - void ReleaseQubit(Qubit qubit) override {} + void ReleaseQubit(Qubit) override {} Result UseZero() override { return reinterpret_cast(0); @@ -984,7 +984,7 @@ struct AdjointsTestSimulator : public SimulatorStub { return reinterpret_cast(++this->lastId); } - void ReleaseQubit(Qubit qubit) override {} + void ReleaseQubit(Qubit) override {} Result UseZero() override { return reinterpret_cast(0); diff --git a/src/Qir/qir-utils.ps1 b/src/Qir/qir-utils.ps1 index c0742679b5d..7e40f8400c3 100644 --- a/src/Qir/qir-utils.ps1 +++ b/src/Qir/qir-utils.ps1 @@ -45,48 +45,29 @@ function Build-CMakeProject { # -Wall # -Wmisleading-indentation, # -Wmost, - # -Wcast-of-sel-type, - # -Wchar-subscripts, - # -Wcomment, - # -Wdelete-non-virtual-dtor, - # -Wextern-c-compat, - # -Wfor-loop-analysis, - # -Wformat, - # -Wframe-address, - # -Wimplicit, - # -Winfinite-recursion, - # -Wint-in-bool-context, - # -Wmismatched-tags, - # -Wmissing-braces, - # -Wmove, - # -Wmultichar, - # -Wobjc-designated-initializers, - # -Wobjc-flexible-array, - # -Wobjc-missing-super-calls, - # -Woverloaded-virtual, - # -Wprivate-extern, - # -Wrange-loop-construct, - # -Wreorder, - # -Wreturn-type, - # -Wself-assign, - # -Wself-move, - # -Wsizeof-array-argument, - # -Wsizeof-array-decay, - # -Wstring-plus-int, - # -Wtautological-compare, - # -Wtrigraphs, - # -Wuninitialized, - # -Wunknown-pragmas, - # -Wunused, - # -Wuser-defined-warnings, - # -Wvolatile-register-var. + # -Wcast-of-sel-type, -Winfinite-recursion, -Woverloaded-virtual, -Wstring-plus-int, + # -Wchar-subscripts, -Wint-in-bool-context, -Wprivate-extern, -Wtautological-compare, + # -Wcomment, -Wmismatched-tags, -Wrange-loop-construct, -Wtrigraphs, + # -Wdelete-non-virtual-dtor, -Wmissing-braces, -Wreorder, -Wuninitialized, + # -Wextern-c-compat, -Wmove, -Wreturn-type, -Wunknown-pragmas, + # -Wfor-loop-analysis, -Wmultichar, -Wself-assign, -Wunused, + # -Wformat, -Wobjc-designated-initializers, -Wself-move, -Wuser-defined-warnings, + # -Wframe-address, -Wobjc-flexible-array, -Wsizeof-array-argument, -Wvolatile-register-var. + # -Wimplicit, -Wobjc-missing-super-calls, -Wsizeof-array-decay, # -Wparentheses, # -Wswitch, # -Wswitch-bool. - # https://clang.llvm.org/docs/DiagnosticsReference.html#wall - $warningFlags += " -Wall" + $warningFlags += " -Wall" # https://clang.llvm.org/docs/DiagnosticsReference.html#wall - $warningFlags += " -Wno-error=unused" # Treat unused entities as warningns rather than errors. https://clang.llvm.org/docs/DiagnosticsReference.html#wunused + # -Wextra + # -Wdeprecated-copy, -Wempty-init-stmt, -Wfuse-ld-path, -Wignored-qualifiers, -Winitializer-overrides, + # -Wmissing-field-initializers, -Wmissing-method-return-type, -Wnull-pointer-arithmetic, + # -Wsemicolon-before-method-body, -Wsign-compare, -Wstring-concatenation, -Wunused-but-set-parameter, + # -Wunused-parameter. + $warningFlags += " -Wextra" # https://clang.llvm.org/docs/DiagnosticsReference.html#wextra + + #$warningFlags += " -Wno-error=unused " # Treat unused entities as warnings rather than errors. https://clang.llvm.org/docs/DiagnosticsReference.html#wunused + #$warningFlags += " -Wno-error=unused-parameter" $env:CFLAGS += $warningFlags $env:CXXFLAGS += $warningFlags From ffb9fd413cfda9411e90eeaa8ec579e4d4152f10 Mon Sep 17 00:00:00 2001 From: Robin Kuzmin Date: Fri, 11 Jun 2021 19:06:46 -0700 Subject: [PATCH 4/8] Release and Test build fix. --- src/Qir/Runtime/lib/QIR/callables.cpp | 3 ++- src/Qir/Runtime/lib/Simulators/ToffoliSimulator.cpp | 1 + src/Qir/Tests/QIR-static/qir-driver.cpp | 12 ++++++------ src/Qir/Tests/QIR-static/qir-test-conditionals.cpp | 12 ++++++------ 4 files changed, 15 insertions(+), 13 deletions(-) diff --git a/src/Qir/Runtime/lib/QIR/callables.cpp b/src/Qir/Runtime/lib/QIR/callables.cpp index c7db55ea269..de9312e7928 100644 --- a/src/Qir/Runtime/lib/QIR/callables.cpp +++ b/src/Qir/Runtime/lib/QIR/callables.cpp @@ -370,7 +370,8 @@ QirTupleHeader* FlattenControlArrays(QirTupleHeader* tuple, int depth) QirArray* controls = current->controls; const size_t blockSize = qubitSize * controls->count; - assert(dst + blockSize <= dstEnd); + assert(dst + blockSize <= dstEnd); + (void)dstEnd; // Calm down the "Unused Var" warning in Release build (`assert()` is Debug only). memcpy(dst, controls->buffer, blockSize); dst += blockSize; // in the last iteration the innerTuple isn't valid, but we are not going to use it diff --git a/src/Qir/Runtime/lib/Simulators/ToffoliSimulator.cpp b/src/Qir/Runtime/lib/Simulators/ToffoliSimulator.cpp index a26232fccf9..d146b8e8969 100644 --- a/src/Qir/Runtime/lib/Simulators/ToffoliSimulator.cpp +++ b/src/Qir/Runtime/lib/Simulators/ToffoliSimulator.cpp @@ -75,6 +75,7 @@ namespace Quantum const long id = GetQubitId(qubit); assert(id <= this->lastUsedId); assert(!this->states.at(id)); + (void)id; // Calm down the "Unused Var" warning in Release build (`assert()` is Debug only). this->lastUsedId--; this->states.pop_back(); } diff --git a/src/Qir/Tests/QIR-static/qir-driver.cpp b/src/Qir/Tests/QIR-static/qir-driver.cpp index 143b3b40c9b..c63e6c0a005 100644 --- a/src/Qir/Tests/QIR-static/qir-driver.cpp +++ b/src/Qir/Tests/QIR-static/qir-driver.cpp @@ -73,7 +73,7 @@ struct QubitsResultsTestSimulator : public Microsoft::Quantum::SimulatorStub { const int id = static_cast(reinterpret_cast(qubit)); REQUIRE(id >= 0); - REQUIRE(id < this->qubits.size()); + REQUIRE((size_t)id < this->qubits.size()); return id; } @@ -82,7 +82,7 @@ struct QubitsResultsTestSimulator : public Microsoft::Quantum::SimulatorStub { const int id = static_cast(reinterpret_cast(result)); REQUIRE(id >= 0); - REQUIRE(id < this->results.size()); + REQUIRE((size_t)id < this->results.size()); return id; } @@ -107,7 +107,7 @@ struct QubitsResultsTestSimulator : public Microsoft::Quantum::SimulatorStub this->qubits[id] = 1 - this->qubits[id]; } - Result Measure(long numBases, PauliId bases[], long numTargets, Qubit targets[]) override + Result Measure(long numBases, PauliId* /* bases */, long /* numTargets */, Qubit targets[]) override { assert(numBases == 1 && "QubitsResultsTestSimulator doesn't support joint measurements"); @@ -223,7 +223,7 @@ struct FunctorsTestSimulator : public Microsoft::Quantum::SimulatorStub { const int id = static_cast(reinterpret_cast(qubit)); REQUIRE(id >= 0); - REQUIRE(id < this->qubits.size()); + REQUIRE((size_t)id < this->qubits.size()); return id; } @@ -261,7 +261,7 @@ struct FunctorsTestSimulator : public Microsoft::Quantum::SimulatorStub X(qubit); } - Result Measure(long numBases, PauliId bases[], long numTargets, Qubit targets[]) override + Result Measure(long numBases, PauliId* /* bases */, long /* numTargets */, Qubit targets[]) override { assert(numBases == 1 && "FunctorsTestSimulator doesn't support joint measurements"); @@ -276,7 +276,7 @@ struct FunctorsTestSimulator : public Microsoft::Quantum::SimulatorStub return (r1 == r2); } - void ReleaseResult(Result result) override {} // the results aren't allocated by this test simulator + void ReleaseResult(Result) override {} // the results aren't allocated by this test simulator Result UseZero() override { diff --git a/src/Qir/Tests/QIR-static/qir-test-conditionals.cpp b/src/Qir/Tests/QIR-static/qir-test-conditionals.cpp index ab16565f211..97c81edb3f3 100644 --- a/src/Qir/Tests/QIR-static/qir-test-conditionals.cpp +++ b/src/Qir/Tests/QIR-static/qir-test-conditionals.cpp @@ -61,14 +61,14 @@ struct ConditionalsTestSimulator : public Microsoft::Quantum::SimulatorStub { return nullptr; } - void ReleaseQubit(Qubit qubit) override {} + void ReleaseQubit(Qubit) override {} void X(Qubit) override { this->xCallbacks.push_back(this->nGateCallback); this->nGateCallback++; } - void ControlledX(long numControls, Qubit controls[], Qubit qubit) override + void ControlledX(long /* numControls */, Qubit* /* controls */, Qubit /* qubit */) override { this->cxCallbacks.push_back(this->nGateCallback); this->nGateCallback++; @@ -78,16 +78,16 @@ struct ConditionalsTestSimulator : public Microsoft::Quantum::SimulatorStub this->otherCallbacks.push_back(this->nGateCallback); this->nGateCallback++; } - void ControlledY(long numControls, Qubit controls[], Qubit qubit) override + void ControlledY(long /* numControls */, Qubit* /* controls */, Qubit /* qubit */) override { this->otherCallbacks.push_back(this->nGateCallback); this->nGateCallback++; } - Result Measure(long numBases, PauliId bases[], long numTargets, Qubit targets[]) override + Result Measure(long /* numBases */, PauliId* /* bases */, long /* numTargets */, Qubit* /* targets */) override { assert( - this->nextMeasureResult < this->mockMeasurements.size() && + (size_t)(this->nextMeasureResult) < this->mockMeasurements.size() && "ConditionalsTestSimulator isn't set up correctly"); Result r = (this->mockMeasurements[this->nextMeasureResult] == Result_Zero) ? UseZero() : UseOne(); @@ -101,7 +101,7 @@ struct ConditionalsTestSimulator : public Microsoft::Quantum::SimulatorStub return (r1 == r2); } - void ReleaseResult(Result result) override {} // the results aren't allocated by this test simulator + void ReleaseResult(Result) override {} // the results aren't allocated by this test simulator Result UseZero() override { From 501c1101e06e5c6b74f05abedb426b2c9215b826 Mon Sep 17 00:00:00 2001 From: Robin Kuzmin Date: Fri, 11 Jun 2021 19:24:09 -0700 Subject: [PATCH 5/8] Minor cleanup --- src/Qir/qir-utils.ps1 | 3 --- 1 file changed, 3 deletions(-) diff --git a/src/Qir/qir-utils.ps1 b/src/Qir/qir-utils.ps1 index 7e40f8400c3..544959d33a4 100644 --- a/src/Qir/qir-utils.ps1 +++ b/src/Qir/qir-utils.ps1 @@ -66,9 +66,6 @@ function Build-CMakeProject { # -Wunused-parameter. $warningFlags += " -Wextra" # https://clang.llvm.org/docs/DiagnosticsReference.html#wextra - #$warningFlags += " -Wno-error=unused " # Treat unused entities as warnings rather than errors. https://clang.llvm.org/docs/DiagnosticsReference.html#wunused - #$warningFlags += " -Wno-error=unused-parameter" - $env:CFLAGS += $warningFlags $env:CXXFLAGS += $warningFlags From 34c14540e9973d7225e91af5b1d1aa61df82ef6d Mon Sep 17 00:00:00 2001 From: Robin Kuzmin Date: Mon, 14 Jun 2021 13:46:11 -0700 Subject: [PATCH 6/8] Build fix. --- src/Qir/Runtime/unittests/QirRuntimeTests.cpp | 2 +- src/Qir/Tests/QIR-static/qir-driver.cpp | 2 ++ 2 files changed, 3 insertions(+), 1 deletion(-) diff --git a/src/Qir/Runtime/unittests/QirRuntimeTests.cpp b/src/Qir/Runtime/unittests/QirRuntimeTests.cpp index e2be510ade7..09ef6c1d6cb 100644 --- a/src/Qir/Runtime/unittests/QirRuntimeTests.cpp +++ b/src/Qir/Runtime/unittests/QirRuntimeTests.cpp @@ -65,7 +65,7 @@ struct ResultsReferenceCountingTestQAPI : public SimulatorStub bool HaveResultsInFlight() const { - for (const auto& b : this->allocated) + for (const auto b : this->allocated) { if (b) { diff --git a/src/Qir/Tests/QIR-static/qir-driver.cpp b/src/Qir/Tests/QIR-static/qir-driver.cpp index c63e6c0a005..a81acec537c 100644 --- a/src/Qir/Tests/QIR-static/qir-driver.cpp +++ b/src/Qir/Tests/QIR-static/qir-driver.cpp @@ -110,6 +110,7 @@ struct QubitsResultsTestSimulator : public Microsoft::Quantum::SimulatorStub Result Measure(long numBases, PauliId* /* bases */, long /* numTargets */, Qubit targets[]) override { assert(numBases == 1 && "QubitsResultsTestSimulator doesn't support joint measurements"); + (void)numBases; // Calm down the compiler warning (unused parameter) for Release build. const int id = GetQubitId(targets[0]); REQUIRE(this->qubits[id] != RELEASED); // the qubit must be alive @@ -264,6 +265,7 @@ struct FunctorsTestSimulator : public Microsoft::Quantum::SimulatorStub Result Measure(long numBases, PauliId* /* bases */, long /* numTargets */, Qubit targets[]) override { assert(numBases == 1 && "FunctorsTestSimulator doesn't support joint measurements"); + (void)numBases; // Calm down the compiler warning (unused parameter) for Release build. const int id = GetQubitId(targets[0]); REQUIRE(this->qubits[id] != RELEASED); From 28fcfbedb2096067b6ff2108e8916fd86334ee06 Mon Sep 17 00:00:00 2001 From: Robin Kuzmin Date: Mon, 14 Jun 2021 14:37:10 -0700 Subject: [PATCH 7/8] Build fix. --- src/Qir/Runtime/unittests/QirRuntimeTests.cpp | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/Qir/Runtime/unittests/QirRuntimeTests.cpp b/src/Qir/Runtime/unittests/QirRuntimeTests.cpp index 09ef6c1d6cb..8c78b0b9f34 100644 --- a/src/Qir/Runtime/unittests/QirRuntimeTests.cpp +++ b/src/Qir/Runtime/unittests/QirRuntimeTests.cpp @@ -716,7 +716,7 @@ struct QubitTestQAPI : public SimulatorStub bool HaveQubitsInFlight() const { - for (const auto& b : this->allocated) + for (const auto b : this->allocated) { if (b) { From 0cd67579e6859fbe035d8b4d5226357077acaf34 Mon Sep 17 00:00:00 2001 From: Robin Kuzmin Date: Mon, 14 Jun 2021 19:03:42 -0700 Subject: [PATCH 8/8] CR changes --- src/Qir/Common/Include/QirUtils.hpp | 7 +++++++ src/Qir/Common/Include/SimulatorStub.hpp | 8 ++++---- src/Qir/Runtime/lib/QIR/CMakeLists.txt | 5 ++++- src/Qir/Runtime/lib/QIR/callables.cpp | 3 ++- src/Qir/Runtime/lib/Simulators/CMakeLists.txt | 5 ++++- src/Qir/Runtime/lib/Simulators/FullstateSimulator.cpp | 10 +--------- src/Qir/Runtime/lib/Simulators/ToffoliSimulator.cpp | 3 ++- src/Qir/Runtime/lib/Tracer/tracer-qis.cpp | 2 +- src/Qir/Runtime/lib/Tracer/tracer.hpp | 4 ++-- src/Qir/Runtime/unittests/QirRuntimeTests.cpp | 4 ++-- src/Qir/Tests/QIR-static/qir-driver.cpp | 7 ++++--- src/Qir/Tests/QIR-static/qir-test-conditionals.cpp | 4 ++-- 12 files changed, 35 insertions(+), 27 deletions(-) create mode 100644 src/Qir/Common/Include/QirUtils.hpp diff --git a/src/Qir/Common/Include/QirUtils.hpp b/src/Qir/Common/Include/QirUtils.hpp new file mode 100644 index 00000000000..e5e351d6844 --- /dev/null +++ b/src/Qir/Common/Include/QirUtils.hpp @@ -0,0 +1,7 @@ +#ifndef QIRUTILS_HPP +#define QIRUTILS_HPP + +// Calm down the "Unused Entity" compiler warning: +#define UNUSED(expr) ((void) (expr)) + +#endif // #ifndef QIRUTILS_HPP \ No newline at end of file diff --git a/src/Qir/Common/Include/SimulatorStub.hpp b/src/Qir/Common/Include/SimulatorStub.hpp index 1c226ad6824..c67ac469f0c 100644 --- a/src/Qir/Common/Include/SimulatorStub.hpp +++ b/src/Qir/Common/Include/SimulatorStub.hpp @@ -93,7 +93,7 @@ namespace Quantum { throw std::logic_error("not_implemented: ControlledExp"); } - void AdjointS(Qubit) override + void AdjointS(Qubit /*target*/) override { throw std::logic_error("not_implemented: AdjointS"); } @@ -113,15 +113,15 @@ namespace Quantum { throw std::logic_error("not_implemented: Measure"); } - void ReleaseResult(Result) override + void ReleaseResult(Result /*result*/) override { throw std::logic_error("not_implemented: ReleaseResult"); } - bool AreEqualResults(Result, Result) override + bool AreEqualResults(Result /*r1*/, Result /*r2*/) override { throw std::logic_error("not_implemented: AreEqualResults"); } - ResultValue GetResultValue(Result) override + ResultValue GetResultValue(Result /*result*/) override { throw std::logic_error("not_implemented: GetResultValue"); } diff --git a/src/Qir/Runtime/lib/QIR/CMakeLists.txt b/src/Qir/Runtime/lib/QIR/CMakeLists.txt index c9812d73d6b..08a30df8cfd 100644 --- a/src/Qir/Runtime/lib/QIR/CMakeLists.txt +++ b/src/Qir/Runtime/lib/QIR/CMakeLists.txt @@ -25,7 +25,10 @@ set(rt_sup_source_files # Produce object lib we'll use to create a shared lib (so/dll) later on add_library(qir-rt-support-obj OBJECT ${rt_sup_source_files}) target_source_from_qir(qir-rt-support-obj bridge-rt.ll) -target_include_directories(qir-rt-support-obj PUBLIC ${public_includes}) +target_include_directories(qir-rt-support-obj PUBLIC + ${public_includes} + ${common_includes} +) set_property(TARGET qir-rt-support-obj PROPERTY POSITION_INDEPENDENT_CODE ON) target_compile_definitions(qir-rt-support-obj PRIVATE EXPORT_QIR_API) diff --git a/src/Qir/Runtime/lib/QIR/callables.cpp b/src/Qir/Runtime/lib/QIR/callables.cpp index de9312e7928..78d475e5f88 100644 --- a/src/Qir/Runtime/lib/QIR/callables.cpp +++ b/src/Qir/Runtime/lib/QIR/callables.cpp @@ -8,6 +8,7 @@ #include #include +#include "QirUtils.hpp" #include "QirContext.hpp" #include "QirTypes.hpp" #include "QirRuntime.hpp" @@ -371,7 +372,7 @@ QirTupleHeader* FlattenControlArrays(QirTupleHeader* tuple, int depth) QirArray* controls = current->controls; const size_t blockSize = qubitSize * controls->count; assert(dst + blockSize <= dstEnd); - (void)dstEnd; // Calm down the "Unused Var" warning in Release build (`assert()` is Debug only). + UNUSED(dstEnd); memcpy(dst, controls->buffer, blockSize); dst += blockSize; // in the last iteration the innerTuple isn't valid, but we are not going to use it diff --git a/src/Qir/Runtime/lib/Simulators/CMakeLists.txt b/src/Qir/Runtime/lib/Simulators/CMakeLists.txt index 589b53283e2..4277958afbb 100644 --- a/src/Qir/Runtime/lib/Simulators/CMakeLists.txt +++ b/src/Qir/Runtime/lib/Simulators/CMakeLists.txt @@ -13,6 +13,9 @@ set(includes # Produce object lib we'll use to create a shared lib (so/dll) later on add_library(simulators-obj OBJECT ${source_files}) -target_include_directories(simulators-obj PUBLIC ${includes}) +target_include_directories(simulators-obj PUBLIC + ${includes} + ${common_includes} +) set_property(TARGET simulators-obj PROPERTY POSITION_INDEPENDENT_CODE ON) target_compile_definitions(simulators-obj PRIVATE EXPORT_QIR_API) diff --git a/src/Qir/Runtime/lib/Simulators/FullstateSimulator.cpp b/src/Qir/Runtime/lib/Simulators/FullstateSimulator.cpp index 501cc734571..e242cfec42d 100644 --- a/src/Qir/Runtime/lib/Simulators/FullstateSimulator.cpp +++ b/src/Qir/Runtime/lib/Simulators/FullstateSimulator.cpp @@ -59,14 +59,6 @@ QUANTUM_SIMULATOR LoadQuantumSimulator() return handle; } -// bool UnloadQuantumSimulator(QUANTUM_SIMULATOR handle) -// { -// #ifdef _WIN32 -// return ::FreeLibrary(handle); -// #else // not _WIN32 -// return ::dlclose(handle); -// #endif -// } void* LoadProc(QUANTUM_SIMULATOR handle, const char* procName) { @@ -224,7 +216,7 @@ namespace Quantum m(this->simulatorId, numBases, reinterpret_cast(bases), ids.data())); } - void ReleaseResult(Result) override {} + void ReleaseResult(Result /*r*/) override {} ResultValue GetResultValue(Result r) override { diff --git a/src/Qir/Runtime/lib/Simulators/ToffoliSimulator.cpp b/src/Qir/Runtime/lib/Simulators/ToffoliSimulator.cpp index d146b8e8969..b1556e1ebf8 100644 --- a/src/Qir/Runtime/lib/Simulators/ToffoliSimulator.cpp +++ b/src/Qir/Runtime/lib/Simulators/ToffoliSimulator.cpp @@ -5,6 +5,7 @@ #include #include +#include "QirUtils.hpp" #include "QirRuntimeApi_I.hpp" #include "QSharpSimApi_I.hpp" #include "SimFactory.hpp" @@ -75,7 +76,7 @@ namespace Quantum const long id = GetQubitId(qubit); assert(id <= this->lastUsedId); assert(!this->states.at(id)); - (void)id; // Calm down the "Unused Var" warning in Release build (`assert()` is Debug only). + UNUSED(id); this->lastUsedId--; this->states.pop_back(); } diff --git a/src/Qir/Runtime/lib/Tracer/tracer-qis.cpp b/src/Qir/Runtime/lib/Tracer/tracer-qis.cpp index 3bf363694d4..37f6a671190 100644 --- a/src/Qir/Runtime/lib/Tracer/tracer-qis.cpp +++ b/src/Qir/Runtime/lib/Tracer/tracer-qis.cpp @@ -25,7 +25,7 @@ extern "C" { } - void quantum__qis__swap(Qubit, Qubit) // NOLINT + void quantum__qis__swap(Qubit /*q1*/, Qubit /*q2*/) // NOLINT { } diff --git a/src/Qir/Runtime/lib/Tracer/tracer.hpp b/src/Qir/Runtime/lib/Tracer/tracer.hpp index 0d65110160e..a49a9b9166e 100644 --- a/src/Qir/Runtime/lib/Tracer/tracer.hpp +++ b/src/Qir/Runtime/lib/Tracer/tracer.hpp @@ -148,11 +148,11 @@ namespace Quantum std::string QubitToString(Qubit qubit) override; void ReleaseResult(Result result) override; - bool AreEqualResults(Result, Result) override + bool AreEqualResults(Result /*r1*/, Result /*r2*/) override { throw std::logic_error("Cannot compare results while tracing!"); } - ResultValue GetResultValue(Result) override + ResultValue GetResultValue(Result /*result*/) override { throw std::logic_error("Result values aren't available while tracing!"); } diff --git a/src/Qir/Runtime/unittests/QirRuntimeTests.cpp b/src/Qir/Runtime/unittests/QirRuntimeTests.cpp index 8c78b0b9f34..8d668a7fd9f 100644 --- a/src/Qir/Runtime/unittests/QirRuntimeTests.cpp +++ b/src/Qir/Runtime/unittests/QirRuntimeTests.cpp @@ -768,7 +768,7 @@ struct ControlledCallablesTestSimulator : public SimulatorStub { return reinterpret_cast(++this->lastId); } - void ReleaseQubit(Qubit) override {} + void ReleaseQubit(Qubit /*qubit*/) override {} Result UseZero() override { return reinterpret_cast(0); @@ -984,7 +984,7 @@ struct AdjointsTestSimulator : public SimulatorStub { return reinterpret_cast(++this->lastId); } - void ReleaseQubit(Qubit) override {} + void ReleaseQubit(Qubit /*qubit*/) override {} Result UseZero() override { return reinterpret_cast(0); diff --git a/src/Qir/Tests/QIR-static/qir-driver.cpp b/src/Qir/Tests/QIR-static/qir-driver.cpp index a81acec537c..b18f5dc264d 100644 --- a/src/Qir/Tests/QIR-static/qir-driver.cpp +++ b/src/Qir/Tests/QIR-static/qir-driver.cpp @@ -8,6 +8,7 @@ #include #include +#include "QirUtils.hpp" #include "CoreTypes.hpp" #include "QirContext.hpp" #include "QirTypes.hpp" @@ -110,7 +111,7 @@ struct QubitsResultsTestSimulator : public Microsoft::Quantum::SimulatorStub Result Measure(long numBases, PauliId* /* bases */, long /* numTargets */, Qubit targets[]) override { assert(numBases == 1 && "QubitsResultsTestSimulator doesn't support joint measurements"); - (void)numBases; // Calm down the compiler warning (unused parameter) for Release build. + UNUSED(numBases); const int id = GetQubitId(targets[0]); REQUIRE(this->qubits[id] != RELEASED); // the qubit must be alive @@ -265,7 +266,7 @@ struct FunctorsTestSimulator : public Microsoft::Quantum::SimulatorStub Result Measure(long numBases, PauliId* /* bases */, long /* numTargets */, Qubit targets[]) override { assert(numBases == 1 && "FunctorsTestSimulator doesn't support joint measurements"); - (void)numBases; // Calm down the compiler warning (unused parameter) for Release build. + UNUSED(numBases); const int id = GetQubitId(targets[0]); REQUIRE(this->qubits[id] != RELEASED); @@ -278,7 +279,7 @@ struct FunctorsTestSimulator : public Microsoft::Quantum::SimulatorStub return (r1 == r2); } - void ReleaseResult(Result) override {} // the results aren't allocated by this test simulator + void ReleaseResult(Result /*result*/) override {} // the results aren't allocated by this test simulator Result UseZero() override { diff --git a/src/Qir/Tests/QIR-static/qir-test-conditionals.cpp b/src/Qir/Tests/QIR-static/qir-test-conditionals.cpp index 97c81edb3f3..4551d301505 100644 --- a/src/Qir/Tests/QIR-static/qir-test-conditionals.cpp +++ b/src/Qir/Tests/QIR-static/qir-test-conditionals.cpp @@ -61,7 +61,7 @@ struct ConditionalsTestSimulator : public Microsoft::Quantum::SimulatorStub { return nullptr; } - void ReleaseQubit(Qubit) override {} + void ReleaseQubit(Qubit /*qubit*/) override {} void X(Qubit) override { @@ -101,7 +101,7 @@ struct ConditionalsTestSimulator : public Microsoft::Quantum::SimulatorStub return (r1 == r2); } - void ReleaseResult(Result) override {} // the results aren't allocated by this test simulator + void ReleaseResult(Result /*result*/) override {} // the results aren't allocated by this test simulator Result UseZero() override {