diff --git a/opencl/test/unit_test/offline_compiler/mock/mock_offline_compiler.h b/opencl/test/unit_test/offline_compiler/mock/mock_offline_compiler.h
index fb8ad271f6..95863937b5 100644
--- a/opencl/test/unit_test/offline_compiler/mock/mock_offline_compiler.h
+++ b/opencl/test/unit_test/offline_compiler/mock/mock_offline_compiler.h
@@ -20,6 +20,7 @@ class MockOclocIgcFacade;
 
 class MockOfflineCompiler : public OfflineCompiler {
   public:
+    using OfflineCompiler::addressingMode;
     using OfflineCompiler::allowCaching;
     using OfflineCompiler::appendExtraInternalOptions;
     using OfflineCompiler::argHelper;
diff --git a/opencl/test/unit_test/offline_compiler/offline_compiler_tests.cpp b/opencl/test/unit_test/offline_compiler/offline_compiler_tests.cpp
index f63eb521b0..25507e6ba1 100644
--- a/opencl/test/unit_test/offline_compiler/offline_compiler_tests.cpp
+++ b/opencl/test/unit_test/offline_compiler/offline_compiler_tests.cpp
@@ -3873,6 +3873,17 @@ TEST_F(OfflineCompilerBindlessOptionsTests, givenBindlessAddressingEnabledWhenAp
     EXPECT_NE(std::string::npos, internalOptions.find(NEO::CompilerOptions::bindlessMode.data()));
 }
 
+TEST_F(OfflineCompilerBindlessOptionsTests, givenBindlessNotEnabledAddrModeSetWhenAppendExtraInternalOptionsThenBindlessModeOptionsAreNotAddedToInternalOptions) {
+    releaseHelper->isBindlessAddressingDisabledResult = false;
+    mockOfflineCompiler->releaseHelper = std::move(releaseHelper);
+    mockOfflineCompiler->addressingMode = "bindful";
+
+    auto internalOptions = mockOfflineCompiler->internalOptions;
+    mockOfflineCompiler->appendExtraInternalOptions(internalOptions);
+
+    EXPECT_EQ(std::string::npos, internalOptions.find(NEO::CompilerOptions::bindlessMode.data()));
+}
+
 TEST_F(OfflineCompilerBindlessOptionsTests, givenBindlessAddressingDisabledWhenAppendExtraInternalOptionsThenBindlessModeOptionsAreNotAddedToInternalOptions) {
     releaseHelper->isBindlessAddressingDisabledResult = true;
     mockOfflineCompiler->releaseHelper = std::move(releaseHelper);
@@ -4431,6 +4442,63 @@ TEST(OfflineCompilerTest, GivenDebugFlagWhenSetStatelessToStatefulBufferOffsetFl
     }
 }
 
+TEST(OclocCompile, GivenStatefulAddressModeWhenInvalidArgsPAssedThenErrorIsReturned) {
+    MockOfflineCompiler ocloc;
+
+    std::vector<std::string> argvA = {
+        "ocloc",
+        "-file",
+        clFiles + "copybuffer.cl",
+        "-device",
+        gEnvironment->devicePrefix.c_str(),
+        "-stateful_address_mode",
+        "wrong"};
+
+    testing::internal::CaptureStdout();
+    int retVal = ocloc.initialize(argvA.size(), argvA);
+    ASSERT_EQ(OCLOC_INVALID_COMMAND_LINE, retVal);
+    std::string output = testing::internal::GetCapturedStdout();
+    EXPECT_STRNE(output.c_str(), "");
+
+    std::vector<std::string> argvB = {
+        "ocloc",
+        "-file",
+        clFiles + "copybuffer.cl",
+        "-device",
+        gEnvironment->devicePrefix.c_str(),
+        "-stateful_address_mode",
+        "bindful",
+        "-internal_options",
+        "-cl-intel-use-bindless-mode "};
+
+    MockOfflineCompiler ocloc2;
+
+    testing::internal::CaptureStdout();
+    retVal = ocloc2.initialize(argvB.size(), argvB);
+    ASSERT_EQ(OCLOC_INVALID_COMMAND_LINE, retVal);
+    output = testing::internal::GetCapturedStdout();
+    EXPECT_STRNE(output.c_str(), "");
+}
+
+TEST(OclocCompile, GivenStatefulAddressModeSetToBindlessWhenBuildThenBindlessModeInternalOptionsAreAdded) {
+    MockOfflineCompiler ocloc;
+
+    std::vector<std::string> argv = {
+        "ocloc",
+        "-file",
+        clFiles + "copybuffer.cl",
+        "-device",
+        gEnvironment->devicePrefix.c_str(),
+        "-stateful_address_mode",
+        "bindless"};
+
+    int retVal = ocloc.initialize(argv.size(), argv);
+    ASSERT_EQ(0, retVal);
+    retVal = ocloc.build();
+    EXPECT_EQ(0, retVal);
+    EXPECT_NE(std::string::npos, ocloc.internalOptions.find(NEO::CompilerOptions::bindlessMode.data()));
+}
+
 struct WhiteBoxOclocArgHelper : public OclocArgHelper {
     using OclocArgHelper::messagePrinter;
     using OclocArgHelper::OclocArgHelper;
diff --git a/shared/offline_compiler/source/offline_compiler.cpp b/shared/offline_compiler/source/offline_compiler.cpp
index aa2709b7b2..519c6f88d9 100644
--- a/shared/offline_compiler/source/offline_compiler.cpp
+++ b/shared/offline_compiler/source/offline_compiler.cpp
@@ -647,6 +647,7 @@ int OfflineCompiler::buildSourceCode() {
     if (igcOutput == nullptr) {
         return OCLOC_OUT_OF_HOST_MEMORY;
     }
+
     UNRECOVERABLE_IF(igcOutput->GetBuildLog() == nullptr);
     UNRECOVERABLE_IF(igcOutput->GetOutput() == nullptr);
     updateBuildLog(igcOutput->GetBuildLog()->GetMemory<char>(), igcOutput->GetBuildLog()->GetSizeRaw());
@@ -1047,6 +1048,9 @@ int OfflineCompiler::parseCommandLine(size_t numArgs, const std::vector<std::str
         } else if ("--format" == currArg) {
             formatToEnforce = argv[argIndex + 1];
             argIndex++;
+        } else if ("-stateful_address_mode" == currArg) {
+            addressingMode = argv[argIndex + 1];
+            argIndex++;
         } else if (("-config" == currArg) && hasMoreArgs) {
             parseHwInfoConfigString(argv[argIndex + 1], hwInfoConfig);
             if (!hwInfoConfig) {
@@ -1073,6 +1077,17 @@ int OfflineCompiler::parseCommandLine(size_t numArgs, const std::vector<std::str
         retVal = OCLOC_INVALID_COMMAND_LINE;
         return retVal;
     }
+    if (!addressingMode.empty()) {
+
+        if (addressingMode != "bindless" && addressingMode != "bindful" && addressingMode != "default") {
+            argHelper->printf("Error: -stateful_address_mode value: %s is invalid\n", addressingMode.c_str());
+            retVal = OCLOC_INVALID_COMMAND_LINE;
+        }
+        if (nullptr != strstr(internalOptions.c_str(), "-cl-intel-use-bindless") && addressingMode == "bindful") {
+            argHelper->printf("Error: option -stateful_address_mode cannot be used with internal_options containing \"-cl-intel-use-bindless\"\n");
+            retVal = OCLOC_INVALID_COMMAND_LINE;
+        }
+    }
     unifyExcludeIrFlags();
 
     if (debugManager.flags.OverrideRevision.get() != -1) {
@@ -1144,7 +1159,8 @@ void OfflineCompiler::appendExtraInternalOptions(std::string &internalOptions) {
     if (compilerProductHelper->isForceEmuInt32DivRemSPRequired()) {
         CompilerOptions::concatenateAppend(internalOptions, CompilerOptions::forceEmuInt32DivRemSP);
     }
-    if (!compilerProductHelper->isBindlessAddressingDisabled(releaseHelper.get())) {
+    if ((!compilerProductHelper->isBindlessAddressingDisabled(releaseHelper.get()) && addressingMode != "bindful") ||
+        addressingMode == "bindless") {
         CompilerOptions::concatenateAppend(internalOptions, CompilerOptions::bindlessMode);
     }
 
@@ -1366,6 +1382,12 @@ Usage: ocloc [compile] -file <filename> -device <device_type> [-output <filename
                                             --format zebin - Enforce generating zebin binary
                                             --format patchtokens - Enforce generating patchtokens (legacy) binary.
 
+  -stateful_address_mode                    Enforce given addressing mode. The possible values are:
+                                            -stateful_address_mode bindful - enforce generating in bindful mode
+                                            -stateful_address_mode bindless - enforce generating in bindless mode
+                                            -stateful_address_mode default - default mode
+                                            not defined: default mode.
+
   -config                                   Target hardware info config for a single device,
                                             e.g 1x4x8.
 
diff --git a/shared/offline_compiler/source/offline_compiler.h b/shared/offline_compiler/source/offline_compiler.h
index 8ebe1c2656..0dee59d954 100644
--- a/shared/offline_compiler/source/offline_compiler.h
+++ b/shared/offline_compiler/source/offline_compiler.h
@@ -177,6 +177,7 @@ All supported acronyms: %s.
     std::string optionsReadFromFile = "";
     std::string internalOptionsReadFromFile = "";
     std::string formatToEnforce = "";
+    std::string addressingMode = "default";
     std::string irHash, genHash, dbgHash, elfHash;
     std::string cacheDir;