diff --git a/level_zero/core/source/debugger/debugger_l0.inl b/level_zero/core/source/debugger/debugger_l0.inl
index 63592ea84c..b2787e813e 100644
--- a/level_zero/core/source/debugger/debugger_l0.inl
+++ b/level_zero/core/source/debugger/debugger_l0.inl
@@ -35,50 +35,56 @@ void DebuggerL0Hw<GfxFamily>::programSbaTrackingCommands(NEO::LinearStream &cmdS
                             sba.IndirectObjectBaseAddress, sba.InstructionBaseAddress, sba.BindlessSurfaceStateBaseAddress);
 
     if (sba.GeneralStateBaseAddress) {
+        auto generalStateBaseAddress = NEO::GmmHelper::decanonize(sba.GeneralStateBaseAddress);
         NEO::EncodeStoreMemory<GfxFamily>::programStoreDataImm(cmdStream,
                                                                gpuAddress + offsetof(SbaTrackedAddresses, GeneralStateBaseAddress),
-                                                               static_cast<uint32_t>(sba.GeneralStateBaseAddress & 0x0000FFFFFFFFULL),
-                                                               static_cast<uint32_t>(sba.GeneralStateBaseAddress >> 32),
+                                                               static_cast<uint32_t>(generalStateBaseAddress & 0x0000FFFFFFFFULL),
+                                                               static_cast<uint32_t>(generalStateBaseAddress >> 32),
                                                                true,
                                                                false);
     }
     if (sba.SurfaceStateBaseAddress) {
+        auto surfaceStateBaseAddress = NEO::GmmHelper::decanonize(sba.SurfaceStateBaseAddress);
         NEO::EncodeStoreMemory<GfxFamily>::programStoreDataImm(cmdStream,
                                                                gpuAddress + offsetof(SbaTrackedAddresses, SurfaceStateBaseAddress),
-                                                               static_cast<uint32_t>(sba.SurfaceStateBaseAddress & 0x0000FFFFFFFFULL),
-                                                               static_cast<uint32_t>(sba.SurfaceStateBaseAddress >> 32),
+                                                               static_cast<uint32_t>(surfaceStateBaseAddress & 0x0000FFFFFFFFULL),
+                                                               static_cast<uint32_t>(surfaceStateBaseAddress >> 32),
                                                                true,
                                                                false);
     }
     if (sba.DynamicStateBaseAddress) {
+        auto dynamicStateBaseAddress = NEO::GmmHelper::decanonize(sba.DynamicStateBaseAddress);
         NEO::EncodeStoreMemory<GfxFamily>::programStoreDataImm(cmdStream,
                                                                gpuAddress + offsetof(SbaTrackedAddresses, DynamicStateBaseAddress),
-                                                               static_cast<uint32_t>(sba.DynamicStateBaseAddress & 0x0000FFFFFFFFULL),
-                                                               static_cast<uint32_t>(sba.DynamicStateBaseAddress >> 32),
+                                                               static_cast<uint32_t>(dynamicStateBaseAddress & 0x0000FFFFFFFFULL),
+                                                               static_cast<uint32_t>(dynamicStateBaseAddress >> 32),
                                                                true,
                                                                false);
     }
     if (sba.IndirectObjectBaseAddress) {
+        auto indirectObjectBaseAddress = NEO::GmmHelper::decanonize(sba.IndirectObjectBaseAddress);
         NEO::EncodeStoreMemory<GfxFamily>::programStoreDataImm(cmdStream,
                                                                gpuAddress + offsetof(SbaTrackedAddresses, IndirectObjectBaseAddress),
-                                                               static_cast<uint32_t>(sba.IndirectObjectBaseAddress & 0x0000FFFFFFFFULL),
-                                                               static_cast<uint32_t>(sba.IndirectObjectBaseAddress >> 32),
+                                                               static_cast<uint32_t>(indirectObjectBaseAddress & 0x0000FFFFFFFFULL),
+                                                               static_cast<uint32_t>(indirectObjectBaseAddress >> 32),
                                                                true,
                                                                false);
     }
     if (sba.InstructionBaseAddress) {
+        auto instructionBaseAddress = NEO::GmmHelper::decanonize(sba.InstructionBaseAddress);
         NEO::EncodeStoreMemory<GfxFamily>::programStoreDataImm(cmdStream,
                                                                gpuAddress + offsetof(SbaTrackedAddresses, InstructionBaseAddress),
-                                                               static_cast<uint32_t>(sba.InstructionBaseAddress & 0x0000FFFFFFFFULL),
-                                                               static_cast<uint32_t>(sba.InstructionBaseAddress >> 32),
+                                                               static_cast<uint32_t>(instructionBaseAddress & 0x0000FFFFFFFFULL),
+                                                               static_cast<uint32_t>(instructionBaseAddress >> 32),
                                                                true,
                                                                false);
     }
     if (sba.BindlessSurfaceStateBaseAddress) {
+        auto bindlessSurfaceStateBaseAddress = NEO::GmmHelper::decanonize(sba.BindlessSurfaceStateBaseAddress);
         NEO::EncodeStoreMemory<GfxFamily>::programStoreDataImm(cmdStream,
                                                                gpuAddress + offsetof(SbaTrackedAddresses, BindlessSurfaceStateBaseAddress),
-                                                               static_cast<uint32_t>(sba.BindlessSurfaceStateBaseAddress & 0x0000FFFFFFFFULL),
-                                                               static_cast<uint32_t>(sba.BindlessSurfaceStateBaseAddress >> 32),
+                                                               static_cast<uint32_t>(bindlessSurfaceStateBaseAddress & 0x0000FFFFFFFFULL),
+                                                               static_cast<uint32_t>(bindlessSurfaceStateBaseAddress >> 32),
                                                                true,
                                                                false);
     }
diff --git a/level_zero/core/test/unit_tests/sources/debugger/test_l0_debugger.cpp b/level_zero/core/test/unit_tests/sources/debugger/test_l0_debugger.cpp
index 165ce222c1..465e602c8a 100644
--- a/level_zero/core/test/unit_tests/sources/debugger/test_l0_debugger.cpp
+++ b/level_zero/core/test/unit_tests/sources/debugger/test_l0_debugger.cpp
@@ -1320,8 +1320,10 @@ HWTEST_F(L0DebuggerSimpleTest, givenNonZeroGpuVasWhenProgrammingSbaTrackingThenC
     cmdSdi = genCmdCast<MI_STORE_DATA_IMM *>(*sdiItor);
 
     expectedGpuVa = debugger->sbaTrackingGpuVa.address + offsetof(SbaTrackedAddresses, DynamicStateBaseAddress);
-    EXPECT_EQ(static_cast<uint32_t>(dsba & 0x0000FFFFFFFFULL), cmdSdi->getDataDword0());
-    EXPECT_EQ(static_cast<uint32_t>(dsba >> 32), cmdSdi->getDataDword1());
+
+    auto decanonizedAddress = GmmHelper::decanonize(dsba);
+    EXPECT_EQ(static_cast<uint32_t>(decanonizedAddress & 0x0000FFFFFFFFULL), cmdSdi->getDataDword0());
+    EXPECT_EQ(static_cast<uint32_t>(decanonizedAddress >> 32), cmdSdi->getDataDword1());
     EXPECT_EQ(expectedGpuVa, cmdSdi->getAddress());
     EXPECT_TRUE(cmdSdi->getStoreQword());
 
@@ -1353,6 +1355,97 @@ HWTEST_F(L0DebuggerSimpleTest, givenNonZeroGpuVasWhenProgrammingSbaTrackingThenC
     EXPECT_TRUE(cmdSdi->getStoreQword());
 }
 
+HWTEST_F(L0DebuggerSimpleTest, givenCanonizedGpuVasWhenProgrammingSbaTrackingThenNonCanonicalAddressesAreStored) {
+    using MI_STORE_DATA_IMM = typename FamilyType::MI_STORE_DATA_IMM;
+    auto debugger = std::make_unique<MockDebuggerL0Hw<FamilyType>>(neoDevice);
+
+    debugger->sbaTrackingGpuVa.address = 0x45670000;
+    auto expectedGpuVa = debugger->sbaTrackingGpuVa.address + offsetof(SbaTrackedAddresses, GeneralStateBaseAddress);
+
+    StackVec<char, 4096> buffer(4096);
+    NEO::LinearStream cmdStream(buffer.begin(), buffer.size());
+    uint64_t gsba = 0xffff800000060000;
+    uint64_t ssba = 0xffff801234567000;
+    uint64_t iba = 0xffff8000fff80000;
+    uint64_t ioba = 0xffff800008100000;
+    uint64_t dsba = 0xffff8000aaaa0000;
+
+    NEO::Debugger::SbaAddresses sbaAddresses = {};
+    sbaAddresses.GeneralStateBaseAddress = gsba;
+    sbaAddresses.SurfaceStateBaseAddress = ssba;
+    sbaAddresses.InstructionBaseAddress = iba;
+    sbaAddresses.IndirectObjectBaseAddress = ioba;
+    sbaAddresses.DynamicStateBaseAddress = dsba;
+    sbaAddresses.BindlessSurfaceStateBaseAddress = ssba;
+
+    debugger->programSbaTrackingCommands(cmdStream, sbaAddresses);
+
+    GenCmdList cmdList;
+    ASSERT_TRUE(FamilyType::PARSE::parseCommandBuffer(cmdList, cmdStream.getCpuBase(), cmdStream.getUsed()));
+
+    EXPECT_EQ(6 * sizeof(MI_STORE_DATA_IMM), cmdStream.getUsed());
+
+    auto sdiItor = find<MI_STORE_DATA_IMM *>(cmdList.begin(), cmdList.end());
+    ASSERT_NE(cmdList.end(), sdiItor);
+    auto cmdSdi = genCmdCast<MI_STORE_DATA_IMM *>(*sdiItor);
+
+    auto decanonizedAddress = GmmHelper::decanonize(gsba);
+    EXPECT_EQ(static_cast<uint32_t>(decanonizedAddress & 0x0000FFFFFFFFULL), cmdSdi->getDataDword0());
+    EXPECT_EQ(static_cast<uint32_t>(decanonizedAddress >> 32), cmdSdi->getDataDword1());
+    EXPECT_EQ(expectedGpuVa, cmdSdi->getAddress());
+    EXPECT_TRUE(cmdSdi->getStoreQword());
+
+    sdiItor++;
+    cmdSdi = genCmdCast<MI_STORE_DATA_IMM *>(*sdiItor);
+
+    expectedGpuVa = debugger->sbaTrackingGpuVa.address + offsetof(SbaTrackedAddresses, SurfaceStateBaseAddress);
+    decanonizedAddress = GmmHelper::decanonize(ssba);
+    EXPECT_EQ(static_cast<uint32_t>(decanonizedAddress & 0x0000FFFFFFFFULL), cmdSdi->getDataDword0());
+    EXPECT_EQ(static_cast<uint32_t>(decanonizedAddress >> 32), cmdSdi->getDataDword1());
+    EXPECT_EQ(expectedGpuVa, cmdSdi->getAddress());
+    EXPECT_TRUE(cmdSdi->getStoreQword());
+
+    sdiItor++;
+    cmdSdi = genCmdCast<MI_STORE_DATA_IMM *>(*sdiItor);
+
+    expectedGpuVa = debugger->sbaTrackingGpuVa.address + offsetof(SbaTrackedAddresses, DynamicStateBaseAddress);
+    decanonizedAddress = GmmHelper::decanonize(dsba);
+    EXPECT_EQ(static_cast<uint32_t>(decanonizedAddress & 0x0000FFFFFFFFULL), cmdSdi->getDataDword0());
+    EXPECT_EQ(static_cast<uint32_t>(decanonizedAddress >> 32), cmdSdi->getDataDword1());
+    EXPECT_EQ(expectedGpuVa, cmdSdi->getAddress());
+    EXPECT_TRUE(cmdSdi->getStoreQword());
+
+    sdiItor++;
+    cmdSdi = genCmdCast<MI_STORE_DATA_IMM *>(*sdiItor);
+
+    expectedGpuVa = debugger->sbaTrackingGpuVa.address + offsetof(SbaTrackedAddresses, IndirectObjectBaseAddress);
+    decanonizedAddress = GmmHelper::decanonize(ioba);
+    EXPECT_EQ(static_cast<uint32_t>(decanonizedAddress & 0x0000FFFFFFFFULL), cmdSdi->getDataDword0());
+    EXPECT_EQ(static_cast<uint32_t>(decanonizedAddress >> 32), cmdSdi->getDataDword1());
+    EXPECT_EQ(expectedGpuVa, cmdSdi->getAddress());
+    EXPECT_TRUE(cmdSdi->getStoreQword());
+
+    sdiItor++;
+    cmdSdi = genCmdCast<MI_STORE_DATA_IMM *>(*sdiItor);
+
+    expectedGpuVa = debugger->sbaTrackingGpuVa.address + offsetof(SbaTrackedAddresses, InstructionBaseAddress);
+    decanonizedAddress = GmmHelper::decanonize(iba);
+    EXPECT_EQ(static_cast<uint32_t>(decanonizedAddress & 0x0000FFFFFFFFULL), cmdSdi->getDataDword0());
+    EXPECT_EQ(static_cast<uint32_t>(decanonizedAddress >> 32), cmdSdi->getDataDword1());
+    EXPECT_EQ(expectedGpuVa, cmdSdi->getAddress());
+    EXPECT_TRUE(cmdSdi->getStoreQword());
+
+    sdiItor++;
+    cmdSdi = genCmdCast<MI_STORE_DATA_IMM *>(*sdiItor);
+
+    expectedGpuVa = debugger->sbaTrackingGpuVa.address + offsetof(SbaTrackedAddresses, BindlessSurfaceStateBaseAddress);
+    decanonizedAddress = GmmHelper::decanonize(ssba);
+    EXPECT_EQ(static_cast<uint32_t>(decanonizedAddress & 0x0000FFFFFFFFULL), cmdSdi->getDataDword0());
+    EXPECT_EQ(static_cast<uint32_t>(decanonizedAddress >> 32), cmdSdi->getDataDword1());
+    EXPECT_EQ(expectedGpuVa, cmdSdi->getAddress());
+    EXPECT_TRUE(cmdSdi->getStoreQword());
+}
+
 HWTEST_F(L0DebuggerSimpleTest, givenZeroGpuVasWhenProgrammingSbaTrackingThenStreamIsNotUsed) {
     using MI_STORE_DATA_IMM = typename FamilyType::MI_STORE_DATA_IMM;
     auto debugger = std::make_unique<MockDebuggerL0Hw<FamilyType>>(neoDevice);