Added compiler warning flags -Wall, -Wextra

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

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");
         }

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)
 

src/Qir/Runtime/lib/QIR/QubitManager.cpp

@@ -397,7 +397,7 @@ Qubit CQubitManager::CreateQubitObject(QubitIdType id)
     return reinterpret_cast<Qubit>(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.
 }

src/Qir/Runtime/lib/QIR/arrays.cpp

@@ -198,7 +198,7 @@ static int64_t GetLinearIndex(const std::vector<int64_t>& dimensionSizes, const
 // It's equal to the product of the dimension sizes in higher dimensions.
 static int64_t RunCount(const std::vector<int64_t>& 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<int64_t>());
 }
 

src/Qir/Runtime/lib/QIR/callables.cpp

@@ -8,6 +8,7 @@
 #include <stdexcept>
 #include <vector>
 
+#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

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<PauliId> 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]);
         }

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)

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<unsigned*>(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<TOp>(this->GetProc("JointEnsembleProbability"));