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 5a2a2459e9f..c67ac469f0c 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 /*target*/) 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 /*result*/) override { throw std::logic_error("not_implemented: ReleaseResult"); } - bool AreEqualResults(Result r1, Result r2) override + bool AreEqualResults(Result /*r1*/, Result /*r2*/) override { throw std::logic_error("not_implemented: AreEqualResults"); } - ResultValue GetResultValue(Result 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/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/QIR/callables.cpp b/src/Qir/Runtime/lib/QIR/callables.cpp index c7db55ea269..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" @@ -370,7 +371,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); + 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/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/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 b6da62d9443..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) { @@ -164,7 +156,7 @@ namespace Quantum } ~CFullstateSimulator() { - if (this->simulatorId != -1) + if (this->simulatorId != (unsigned)-1) { typedef unsigned (*TDestroy)(unsigned); static TDestroy destroySimulatorInstance = @@ -224,7 +216,7 @@ namespace Quantum m(this->simulatorId, numBases, reinterpret_cast(bases), ids.data())); } - void ReleaseResult(Result r) override {} + void ReleaseResult(Result /*r*/) override {} ResultValue GetResultValue(Result r) override { @@ -408,7 +400,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..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" @@ -42,7 +43,7 @@ namespace Quantum /// /// Implementation of IRuntimeDriver /// - void ReleaseResult(Result result) override {} + void ReleaseResult(Result /* result */) override {} bool AreEqualResults(Result r1, Result r2) override { @@ -75,6 +76,7 @@ namespace Quantum const long id = GetQubitId(qubit); assert(id <= this->lastUsedId); assert(!this->states.at(id)); + UNUSED(id); this->lastUsedId--; this->states.pop_back(); } @@ -88,7 +90,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 +103,7 @@ namespace Quantum Qubit targets[], double probabilityOfZero, double precision, - const char* failureMessage) override + const char* /* failureMessage */) override { assert(precision >= 0); @@ -111,17 +113,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 +156,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 +177,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..37f6a671190 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 /*q1*/, Qubit /*q2*/) // 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..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 r1, Result r2) override + bool AreEqualResults(Result /*r1*/, Result /*r2*/) override { throw std::logic_error("Cannot compare results while tracing!"); } - ResultValue GetResultValue(Result 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 66127fb69ae..8d668a7fd9f 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) { @@ -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) { @@ -768,7 +768,7 @@ struct ControlledCallablesTestSimulator : public SimulatorStub { return reinterpret_cast(++this->lastId); } - void ReleaseQubit(Qubit 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 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 143b3b40c9b..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" @@ -73,7 +74,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 +83,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,9 +108,10 @@ 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"); + UNUSED(numBases); const int id = GetQubitId(targets[0]); REQUIRE(this->qubits[id] != RELEASED); // the qubit must be alive @@ -223,7 +225,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,9 +263,10 @@ 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"); + UNUSED(numBases); const int id = GetQubitId(targets[0]); REQUIRE(this->qubits[id] != RELEASED); @@ -276,7 +279,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 /*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..4551d301505 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 /*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 /*result*/) override {} // the results aren't allocated by this test simulator Result UseZero() override { diff --git a/src/Qir/qir-utils.ps1 b/src/Qir/qir-utils.ps1 index d5b577a26e3..544959d33a4 100644 --- a/src/Qir/qir-utils.ps1 +++ b/src/Qir/qir-utils.ps1 @@ -41,6 +41,31 @@ function Build-CMakeProject { $clangTidy = "" $warningFlags = "-Werror" + + # -Wall + # -Wmisleading-indentation, + # -Wmost, + # -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. + $warningFlags += " -Wall" # https://clang.llvm.org/docs/DiagnosticsReference.html#wall + + # -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 + $env:CFLAGS += $warningFlags $env:CXXFLAGS += $warningFlags